X-Git-Url: https://git.wh0rd.org/?p=ICEs.git;a=blobdiff_plain;f=321197%2Fpyside.ii.0;fp=321197%2Fpyside.ii.0;h=502bb2422a05abe4988b93c23c56d217df016c71;hp=0000000000000000000000000000000000000000;hb=bd3239d2bbe0de3a200b266503e3330b1e391489;hpb=dbff64cb4b7530861c2309c794efdd4e0cf47a23

diff --git a/321197/pyside.ii.0 b/321197/pyside.ii.0
new file mode 100644
index 0000000..502bb24
--- /dev/null
+++ b/321197/pyside.ii.0
@@ -0,0 +1,124028 @@
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp"
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit//"
+# 1 "<built-in>"
+# 1 "<command-line>"
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp"
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp"
+# 1 "/usr/include/qt4/QtWebKit/qwebpage.h" 1
+# 24 "/usr/include/qt4/QtWebKit/qwebpage.h"
+# 1 "/usr/include/qt4/QtWebKit/qwebsettings.h" 1
+# 23 "/usr/include/qt4/QtWebKit/qwebsettings.h"
+# 1 "/usr/include/qt4/QtWebKit/qwebkitglobal.h" 1
+# 23 "/usr/include/qt4/QtWebKit/qwebkitglobal.h"
+# 1 "/usr/include/qt4/QtCore/qglobal.h" 1
+# 45 "/usr/include/qt4/QtCore/qglobal.h"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 3 4
+typedef long int ptrdiff_t;
+# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 3 4
+typedef long unsigned int size_t;
+# 46 "/usr/include/qt4/QtCore/qglobal.h" 2
+# 62 "/usr/include/qt4/QtCore/qglobal.h"
+# 1 "/usr/include/qt4/QtCore/qconfig.h" 1
+
+
+# 1 "/usr/include/qt4/Gentoo/gentoo-qconfig.h" 1
+# 4 "/usr/include/qt4/QtCore/qconfig.h" 2
+# 63 "/usr/include/qt4/QtCore/qglobal.h" 2
+# 828 "/usr/include/qt4/QtCore/qglobal.h"
+
+
+
+
+
+
+
+
+
+typedef signed char qint8;
+typedef unsigned char quint8;
+typedef short qint16;
+typedef unsigned short quint16;
+typedef int qint32;
+typedef unsigned int quint32;
+# 851 "/usr/include/qt4/QtCore/qglobal.h"
+typedef long long qint64;
+typedef unsigned long long quint64;
+
+
+typedef qint64 qlonglong;
+typedef quint64 qulonglong;
+# 881 "/usr/include/qt4/QtCore/qglobal.h"
+template <int> struct QIntegerForSize;
+template <> struct QIntegerForSize<1> { typedef quint8 Unsigned; typedef qint8 Signed; };
+template <> struct QIntegerForSize<2> { typedef quint16 Unsigned; typedef qint16 Signed; };
+template <> struct QIntegerForSize<4> { typedef quint32 Unsigned; typedef qint32 Signed; };
+template <> struct QIntegerForSize<8> { typedef quint64 Unsigned; typedef qint64 Signed; };
+template <class T> struct QIntegerForSizeof: QIntegerForSize<sizeof(T)> { };
+typedef QIntegerForSizeof<void*>::Unsigned quintptr;
+typedef QIntegerForSizeof<void*>::Signed qptrdiff;
+
+
+
+
+
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+# 1063 "/usr/include/qt4/QtCore/qglobal.h"
+typedef int QNoImplicitBoolCast;
+# 1075 "/usr/include/qt4/QtCore/qglobal.h"
+typedef double qreal;
+
+
+
+
+
+
+template <typename T>
+inline T qAbs(const T &t) { return t >= 0 ? t : -t; }
+
+inline int qRound(qreal d)
+{ return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); }
+
+
+
+
+
+inline qint64 qRound64(qreal d)
+{ return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qreal(qint64(d-1)) + 0.5) + qint64(d-1); }
+
+
+template <typename T>
+inline const T &qMin(const T &a, const T &b) { if (a < b) return a; return b; }
+template <typename T>
+inline const T &qMax(const T &a, const T &b) { if (a < b) return b; return a; }
+template <typename T>
+inline const T &qBound(const T &min, const T &val, const T &max)
+{ return qMax(min, qMin(max, val)); }
+# 1133 "/usr/include/qt4/QtCore/qglobal.h"
+class QDataStream;
+# 1158 "/usr/include/qt4/QtCore/qglobal.h"
+# 1 "/usr/include/qt4/QtCore/qfeatures.h" 1
+# 1159 "/usr/include/qt4/QtCore/qglobal.h" 2
+# 1368 "/usr/include/qt4/QtCore/qglobal.h"
+inline void qt_noop() {}
+# 1401 "/usr/include/qt4/QtCore/qglobal.h"
+class QString;
+class QSysInfo {
+public:
+    enum Sizes {
+        WordSize = (sizeof(void *)<<3)
+    };
+# 1416 "/usr/include/qt4/QtCore/qglobal.h"
+    enum Endian {
+        BigEndian,
+        LittleEndian
+
+
+
+
+
+
+        , ByteOrder = LittleEndian
+
+
+
+    };
+# 1519 "/usr/include/qt4/QtCore/qglobal.h"
+};
+
+ const char *qVersion();
+ bool qSharedBuild();
+# 1592 "/usr/include/qt4/QtCore/qglobal.h"
+ void qDebug(const char *, ...)
+
+    __attribute__ ((format (printf, 1, 2)))
+
+;
+
+ void qWarning(const char *, ...)
+
+    __attribute__ ((format (printf, 1, 2)))
+
+;
+
+class QString;
+ QString qt_error_string(int errorCode = -1);
+ void qCritical(const char *, ...)
+
+    __attribute__ ((format (printf, 1, 2)))
+
+;
+ void qFatal(const char *, ...)
+
+    __attribute__ ((format (printf, 1, 2)))
+
+;
+
+
+
+
+ void qErrnoWarning(int code, const char *msg, ...);
+ void qErrnoWarning(const char *msg, ...);
+# 1632 "/usr/include/qt4/QtCore/qglobal.h"
+class QDebug;
+class QNoDebug;
+
+ inline QDebug qDebug();
+ inline QDebug qWarning();
+ inline QDebug qCritical();
+# 1652 "/usr/include/qt4/QtCore/qglobal.h"
+ void qt_assert(const char *assertion, const char *file, int line);
+# 1666 "/usr/include/qt4/QtCore/qglobal.h"
+ void qt_assert_x(const char *where, const char *what, const char *file, int line);
+# 1676 "/usr/include/qt4/QtCore/qglobal.h"
+ void qt_check_pointer(const char *, int);
+
+
+ void qBadAlloc();
+# 1692 "/usr/include/qt4/QtCore/qglobal.h"
+template <typename T>
+inline T *q_check_ptr(T *p) { do { if (!(p)) qBadAlloc(); } while (0); return p; }
+# 1722 "/usr/include/qt4/QtCore/qglobal.h"
+enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg = QtCriticalMsg };
+
+ void qt_message_output(QtMsgType, const char *buf);
+
+typedef void (*QtMsgHandler)(QtMsgType, const char *);
+ QtMsgHandler qInstallMsgHandler(QtMsgHandler);
+# 1776 "/usr/include/qt4/QtCore/qglobal.h"
+template <typename T> class QBasicAtomicPointer;
+
+
+template <typename T>
+class QGlobalStatic
+{
+public:
+    QBasicAtomicPointer<T> pointer;
+    bool destroyed;
+};
+
+
+template <typename T>
+class QGlobalStaticDeleter
+{
+public:
+    QGlobalStatic<T> &globalStatic;
+    QGlobalStaticDeleter(QGlobalStatic<T> &_globalStatic)
+        : globalStatic(_globalStatic)
+    { }
+
+    inline ~QGlobalStaticDeleter()
+    {
+        delete globalStatic.pointer;
+        globalStatic.pointer = 0;
+        globalStatic.destroyed = true;
+    }
+};
+# 1853 "/usr/include/qt4/QtCore/qglobal.h"
+class QBool
+{
+    bool b;
+
+public:
+    inline explicit QBool(bool B) : b(B) {}
+    inline operator const void *() const
+    { return b ? static_cast<const void *>(this) : static_cast<const void *>(0); }
+};
+
+inline bool operator==(QBool b1, bool b2) { return !b1 == !b2; }
+inline bool operator==(bool b1, QBool b2) { return !b1 == !b2; }
+inline bool operator==(QBool b1, QBool b2) { return !b1 == !b2; }
+inline bool operator!=(QBool b1, bool b2) { return !b1 != !b2; }
+inline bool operator!=(bool b1, QBool b2) { return !b1 != !b2; }
+inline bool operator!=(QBool b1, QBool b2) { return !b1 != !b2; }
+
+static inline bool qFuzzyCompare(double p1, double p2)
+{
+    return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2)));
+}
+
+static inline bool qFuzzyCompare(float p1, float p2)
+{
+    return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2)));
+}
+
+
+
+
+static inline bool qFuzzyIsNull(double d)
+{
+    return qAbs(d) <= 0.000000000001;
+}
+
+
+
+
+static inline bool qFuzzyIsNull(float f)
+{
+    return qAbs(f) <= 0.00001f;
+}
+
+
+
+
+
+
+static inline bool qIsNull(double d)
+{
+    union U {
+        double d;
+        quint64 u;
+    };
+    U val;
+    val.d = d;
+    return val.u == quint64(0);
+}
+
+
+
+
+
+
+static inline bool qIsNull(float f)
+{
+    union U {
+        float f;
+        quint32 u;
+    };
+    U val;
+    val.f = f;
+    return val.u == 0u;
+}
+# 1959 "/usr/include/qt4/QtCore/qglobal.h"
+template <typename T> inline bool qIsDetached(T &) { return true; }
+
+template <typename T>
+class QTypeInfo
+{
+public:
+    enum {
+        isPointer = false,
+        isComplex = true,
+        isStatic = true,
+        isLarge = (sizeof(T)>sizeof(void*)),
+        isDummy = false
+    };
+};
+
+template <typename T>
+class QTypeInfo<T*>
+{
+public:
+    enum {
+        isPointer = true,
+        isComplex = false,
+        isStatic = false,
+        isLarge = false,
+        isDummy = false
+    };
+};
+# 2017 "/usr/include/qt4/QtCore/qglobal.h"
+enum {
+    Q_COMPLEX_TYPE = 0,
+    Q_PRIMITIVE_TYPE = 0x1,
+    Q_STATIC_TYPE = 0,
+    Q_MOVABLE_TYPE = 0x2,
+    Q_DUMMY_TYPE = 0x4
+};
+# 2040 "/usr/include/qt4/QtCore/qglobal.h"
+template <typename T>
+inline void qSwap(T &value1, T &value2)
+{
+    const T t = value1;
+    value1 = value2;
+    value2 = t;
+}
+# 2067 "/usr/include/qt4/QtCore/qglobal.h"
+template <> class QTypeInfo<bool > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(bool)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "bool"; } };
+template <> class QTypeInfo<char > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "char"; } };
+template <> class QTypeInfo<signed char > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(signed char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "signed char"; } };
+template <> class QTypeInfo<uchar > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uchar)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uchar"; } };
+template <> class QTypeInfo<short > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(short)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "short"; } };
+template <> class QTypeInfo<ushort > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ushort)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ushort"; } };
+template <> class QTypeInfo<int > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(int)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "int"; } };
+template <> class QTypeInfo<uint > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uint"; } };
+template <> class QTypeInfo<long > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long"; } };
+template <> class QTypeInfo<ulong > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ulong)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ulong"; } };
+template <> class QTypeInfo<qint64 > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(qint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "qint64"; } };
+template <> class QTypeInfo<quint64 > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(quint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "quint64"; } };
+template <> class QTypeInfo<float > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(float)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "float"; } };
+template <> class QTypeInfo<double > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "double"; } };
+
+template <> class QTypeInfo<long double > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long double"; } };
+
+
+
+
+
+
+ void *qMalloc(size_t size);
+ void qFree(void *ptr);
+ void *qRealloc(void *ptr, size_t size);
+ void *qMallocAligned(size_t size, size_t alignment);
+ void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment);
+ void qFreeAligned(void *ptr);
+ void *qMemCopy(void *dest, const void *src, size_t n);
+ void *qMemSet(void *dest, int c, size_t n);
+# 2137 "/usr/include/qt4/QtCore/qglobal.h"
+class QFlag
+{
+    int i;
+public:
+    inline QFlag(int i);
+    inline operator int() const { return i; }
+};
+
+inline QFlag::QFlag(int ai) : i(ai) {}
+
+class QIncompatibleFlag
+{
+    int i;
+public:
+    inline explicit QIncompatibleFlag(int i);
+    inline operator int() const { return i; }
+};
+
+inline QIncompatibleFlag::QIncompatibleFlag(int ai) : i(ai) {}
+
+
+
+
+template<typename Enum>
+class QFlags
+{
+    typedef void **Zero;
+    int i;
+public:
+    typedef Enum enum_type;
+    inline QFlags(const QFlags &f) : i(f.i) {}
+    inline QFlags(Enum f) : i(f) {}
+    inline QFlags(Zero = 0) : i(0) {}
+    inline QFlags(QFlag f) : i(f) {}
+
+    inline QFlags &operator=(const QFlags &f) { i = f.i; return *this; }
+    inline QFlags &operator&=(int mask) { i &= mask; return *this; }
+    inline QFlags &operator&=(uint mask) { i &= mask; return *this; }
+    inline QFlags &operator|=(QFlags f) { i |= f.i; return *this; }
+    inline QFlags &operator|=(Enum f) { i |= f; return *this; }
+    inline QFlags &operator^=(QFlags f) { i ^= f.i; return *this; }
+    inline QFlags &operator^=(Enum f) { i ^= f; return *this; }
+
+    inline operator int() const { return i; }
+
+    inline QFlags operator|(QFlags f) const { QFlags g; g.i = i | f.i; return g; }
+    inline QFlags operator|(Enum f) const { QFlags g; g.i = i | f; return g; }
+    inline QFlags operator^(QFlags f) const { QFlags g; g.i = i ^ f.i; return g; }
+    inline QFlags operator^(Enum f) const { QFlags g; g.i = i ^ f; return g; }
+    inline QFlags operator&(int mask) const { QFlags g; g.i = i & mask; return g; }
+    inline QFlags operator&(uint mask) const { QFlags g; g.i = i & mask; return g; }
+    inline QFlags operator&(Enum f) const { QFlags g; g.i = i & f; return g; }
+    inline QFlags operator~() const { QFlags g; g.i = ~i; return g; }
+
+    inline bool operator!() const { return !i; }
+
+    inline bool testFlag(Enum f) const { return (i & f) == f && (f != 0 || i == int(f) ); }
+};
+# 2224 "/usr/include/qt4/QtCore/qglobal.h"
+template <typename T>
+class QForeachContainer {
+public:
+    inline QForeachContainer(const T& t) : c(t), brk(0), i(c.begin()), e(c.end()) { }
+    const T c;
+    int brk;
+    typename T::const_iterator i, e;
+};
+# 2316 "/usr/include/qt4/QtCore/qglobal.h"
+template <typename T> static inline T *qGetPtrHelper(T *ptr) { return ptr; }
+template <typename Wrapper> static inline typename Wrapper::pointer qGetPtrHelper(const Wrapper &p) { return p.data(); }
+# 2349 "/usr/include/qt4/QtCore/qglobal.h"
+ QString qtTrId(const char *id, int n = -1);
+# 2379 "/usr/include/qt4/QtCore/qglobal.h"
+class QByteArray;
+ QByteArray qgetenv(const char *varName);
+ bool qputenv(const char *varName, const QByteArray& value);
+
+inline int qIntCast(double f) { return int(f); }
+inline int qIntCast(float f) { return int(f); }
+
+
+
+
+ void qsrand(uint seed);
+ int qrand();
+# 2552 "/usr/include/qt4/QtCore/qglobal.h"
+enum QtValidLicenseForCoreModule { LicensedCore = true };
+
+
+enum QtValidLicenseForGuiModule { LicensedGui = true };
+
+
+enum QtValidLicenseForNetworkModule { LicensedNetwork = true };
+
+
+enum QtValidLicenseForOpenGLModule { LicensedOpenGL = true };
+
+
+enum QtValidLicenseForOpenVGModule { LicensedOpenVG = true };
+
+
+enum QtValidLicenseForSqlModule { LicensedSql = true };
+
+
+enum QtValidLicenseForMultimediaModule { LicensedMultimedia = true };
+
+
+enum QtValidLicenseForXmlModule { LicensedXml = true };
+
+
+enum QtValidLicenseForXmlPatternsModule { LicensedXmlPatterns = true };
+
+
+enum QtValidLicenseForHelpModule { LicensedHelp = true };
+
+
+enum QtValidLicenseForScriptModule { LicensedScript = true };
+
+
+enum QtValidLicenseForScriptToolsModule { LicensedScriptTools = true };
+
+
+enum QtValidLicenseForQt3SupportLightModule { LicensedQt3SupportLight = true };
+
+
+enum QtValidLicenseForQt3SupportModule { LicensedQt3Support = true };
+
+
+enum QtValidLicenseForSvgModule { LicensedSvg = true };
+
+
+enum QtValidLicenseForDeclarativeModule { LicensedDeclarative = true };
+
+
+enum QtValidLicenseForActiveQtModule { LicensedActiveQt = true };
+
+
+enum QtValidLicenseForTestModule { LicensedTest = true };
+
+
+enum QtValidLicenseForDBusModule { LicensedDBus = true };
+# 2640 "/usr/include/qt4/QtCore/qglobal.h"
+
+
+# 24 "/usr/include/qt4/QtWebKit/qwebkitglobal.h" 2
+# 24 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2
+
+# 1 "/usr/include/qt4/QtCore/qstring.h" 1
+# 45 "/usr/include/qt4/QtCore/qstring.h"
+# 1 "/usr/include/qt4/QtCore/qchar.h" 1
+# 47 "/usr/include/qt4/QtCore/qchar.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QString;
+
+struct QLatin1Char
+{
+public:
+    inline explicit QLatin1Char(char c) : ch(c) {}
+
+
+
+
+    inline char toLatin1() const { return ch; }
+    inline ushort unicode() const { return ushort(uchar(ch)); }
+
+
+private:
+    char ch;
+};
+
+
+class QChar {
+public:
+    QChar();
+
+    QChar(char c);
+    QChar(uchar c);
+
+    QChar(QLatin1Char ch);
+    QChar(uchar c, uchar r);
+    inline QChar(ushort rc) : ucs(rc){}
+    QChar(short rc);
+    QChar(uint rc);
+    QChar(int rc);
+    enum SpecialCharacter {
+        Null = 0x0000,
+        Nbsp = 0x00a0,
+        ReplacementCharacter = 0xfffd,
+        ObjectReplacementCharacter = 0xfffc,
+        ByteOrderMark = 0xfeff,
+        ByteOrderSwapped = 0xfffe,
+
+
+
+
+
+
+
+        ParagraphSeparator = 0x2029,
+        LineSeparator = 0x2028
+    };
+    QChar(SpecialCharacter sc);
+
+
+
+    enum Category
+    {
+        NoCategory,
+
+        Mark_NonSpacing,
+        Mark_SpacingCombining,
+        Mark_Enclosing,
+
+        Number_DecimalDigit,
+        Number_Letter,
+        Number_Other,
+
+        Separator_Space,
+        Separator_Line,
+        Separator_Paragraph,
+
+        Other_Control,
+        Other_Format,
+        Other_Surrogate,
+        Other_PrivateUse,
+        Other_NotAssigned,
+
+        Letter_Uppercase,
+        Letter_Lowercase,
+        Letter_Titlecase,
+        Letter_Modifier,
+        Letter_Other,
+
+        Punctuation_Connector,
+        Punctuation_Dash,
+        Punctuation_Open,
+        Punctuation_Close,
+        Punctuation_InitialQuote,
+        Punctuation_FinalQuote,
+        Punctuation_Other,
+
+        Symbol_Math,
+        Symbol_Currency,
+        Symbol_Modifier,
+        Symbol_Other,
+
+        Punctuation_Dask = Punctuation_Dash
+    };
+
+    enum Direction
+    {
+        DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
+        DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
+    };
+
+    enum Decomposition
+    {
+        NoDecomposition,
+        Canonical,
+        Font,
+        NoBreak,
+        Initial,
+        Medial,
+        Final,
+        Isolated,
+        Circle,
+        Super,
+        Sub,
+        Vertical,
+        Wide,
+        Narrow,
+        Small,
+        Square,
+        Compat,
+        Fraction
+
+
+
+
+    };
+
+    enum Joining
+    {
+        OtherJoining, Dual, Right, Center
+    };
+
+    enum CombiningClass
+    {
+        Combining_BelowLeftAttached = 200,
+        Combining_BelowAttached = 202,
+        Combining_BelowRightAttached = 204,
+        Combining_LeftAttached = 208,
+        Combining_RightAttached = 210,
+        Combining_AboveLeftAttached = 212,
+        Combining_AboveAttached = 214,
+        Combining_AboveRightAttached = 216,
+
+        Combining_BelowLeft = 218,
+        Combining_Below = 220,
+        Combining_BelowRight = 222,
+        Combining_Left = 224,
+        Combining_Right = 226,
+        Combining_AboveLeft = 228,
+        Combining_Above = 230,
+        Combining_AboveRight = 232,
+
+        Combining_DoubleBelow = 233,
+        Combining_DoubleAbove = 234,
+        Combining_IotaSubscript = 240
+    };
+
+    enum UnicodeVersion {
+        Unicode_Unassigned,
+        Unicode_1_1,
+        Unicode_2_0,
+        Unicode_2_1_2,
+        Unicode_3_0,
+        Unicode_3_1,
+        Unicode_3_2,
+        Unicode_4_0,
+        Unicode_4_1,
+        Unicode_5_0
+    };
+
+
+    Category category() const;
+    Direction direction() const;
+    Joining joining() const;
+    bool hasMirrored() const;
+    unsigned char combiningClass() const;
+
+    QChar mirroredChar() const;
+    QString decomposition() const;
+    Decomposition decompositionTag() const;
+
+    int digitValue() const;
+    QChar toLower() const;
+    QChar toUpper() const;
+    QChar toTitleCase() const;
+    QChar toCaseFolded() const;
+
+    UnicodeVersion unicodeVersion() const;
+
+
+
+
+
+
+    char toAscii() const;
+    inline char toLatin1() const;
+    inline ushort unicode() const { return ucs; }
+
+
+    inline ushort &unicode() { return const_cast<ushort&>(ucs); }
+
+
+
+
+    static QChar fromAscii(char c);
+    static QChar fromLatin1(char c);
+
+    inline bool isNull() const { return ucs == 0; }
+    bool isPrint() const;
+    bool isPunct() const;
+    bool isSpace() const;
+    bool isMark() const;
+    bool isLetter() const;
+    bool isNumber() const;
+    bool isLetterOrNumber() const;
+    bool isDigit() const;
+    bool isSymbol() const;
+    inline bool isLower() const { return category() == Letter_Lowercase; }
+    inline bool isUpper() const { return category() == Letter_Uppercase; }
+    inline bool isTitleCase() const { return category() == Letter_Titlecase; }
+
+    inline bool isHighSurrogate() const {
+        return ((ucs & 0xfc00) == 0xd800);
+    }
+    inline bool isLowSurrogate() const {
+        return ((ucs & 0xfc00) == 0xdc00);
+    }
+
+    inline uchar cell() const { return uchar(ucs & 0xff); }
+    inline uchar row() const { return uchar((ucs>>8)&0xff); }
+    inline void setCell(uchar cell);
+    inline void setRow(uchar row);
+
+    static inline uint surrogateToUcs4(ushort high, ushort low) {
+        return (uint(high)<<10) + low - 0x35fdc00;
+    }
+    static inline uint surrogateToUcs4(QChar high, QChar low) {
+        return (uint(high.ucs)<<10) + low.ucs - 0x35fdc00;
+    }
+    static inline ushort highSurrogate(uint ucs4) {
+        return ushort((ucs4>>10) + 0xd7c0);
+    }
+    static inline ushort lowSurrogate(uint ucs4) {
+        return ushort(ucs4%0x400 + 0xdc00);
+    }
+
+    static Category category(uint ucs4);
+    static Category category(ushort ucs2);
+    static Direction direction(uint ucs4);
+    static Direction direction(ushort ucs2);
+    static Joining joining(uint ucs4);
+    static Joining joining(ushort ucs2);
+    static unsigned char combiningClass(uint ucs4);
+    static unsigned char combiningClass(ushort ucs2);
+
+    static uint mirroredChar(uint ucs4);
+    static ushort mirroredChar(ushort ucs2);
+    static Decomposition decompositionTag(uint ucs4);
+
+    static int digitValue(uint ucs4);
+    static int digitValue(ushort ucs2);
+    static uint toLower(uint ucs4);
+    static ushort toLower(ushort ucs2);
+    static uint toUpper(uint ucs4);
+    static ushort toUpper(ushort ucs2);
+    static uint toTitleCase(uint ucs4);
+    static ushort toTitleCase(ushort ucs2);
+    static uint toCaseFolded(uint ucs4);
+    static ushort toCaseFolded(ushort ucs2);
+
+    static UnicodeVersion unicodeVersion(uint ucs4);
+    static UnicodeVersion unicodeVersion(ushort ucs2);
+
+    static QString decomposition(uint ucs4);
+# 346 "/usr/include/qt4/QtCore/qchar.h"
+private:
+
+
+
+
+    ushort ucs;
+}
+
+
+
+    ;
+
+template <> class QTypeInfo<QChar > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QChar)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QChar"; } };
+
+inline QChar::QChar() : ucs(0) {}
+
+
+
+
+inline char QChar::toLatin1() const { return ucs > 0xff ? '\0' : char(ucs); }
+
+inline QChar QChar::fromLatin1(char c) { return QChar(ushort(uchar(c))); }
+
+inline QChar::QChar(uchar c, uchar r) : ucs(ushort((r << 8) | c)){}
+inline QChar::QChar(short rc) : ucs(ushort(rc)){}
+inline QChar::QChar(uint rc) : ucs(ushort(rc & 0xffff)){}
+inline QChar::QChar(int rc) : ucs(ushort(rc & 0xffff)){}
+inline QChar::QChar(SpecialCharacter s) : ucs(ushort(s)) {}
+inline QChar::QChar(QLatin1Char ch) : ucs(ch.unicode()) {}
+
+inline void QChar::setCell(uchar acell)
+{ ucs = ushort((ucs & 0xff00) + acell); }
+inline void QChar::setRow(uchar arow)
+{ ucs = ushort((ushort(arow)<<8) + (ucs&0xff)); }
+
+inline bool operator==(QChar c1, QChar c2) { return c1.unicode() == c2.unicode(); }
+inline bool operator!=(QChar c1, QChar c2) { return c1.unicode() != c2.unicode(); }
+inline bool operator<=(QChar c1, QChar c2) { return c1.unicode() <= c2.unicode(); }
+inline bool operator>=(QChar c1, QChar c2) { return c1.unicode() >= c2.unicode(); }
+inline bool operator<(QChar c1, QChar c2) { return c1.unicode() < c2.unicode(); }
+inline bool operator>(QChar c1, QChar c2) { return c1.unicode() > c2.unicode(); }
+
+
+ QDataStream &operator<<(QDataStream &, const QChar &);
+ QDataStream &operator>>(QDataStream &, QChar &);
+
+
+
+
+
+# 46 "/usr/include/qt4/QtCore/qstring.h" 2
+# 1 "/usr/include/qt4/QtCore/qbytearray.h" 1
+# 45 "/usr/include/qt4/QtCore/qbytearray.h"
+# 1 "/usr/include/qt4/QtCore/qatomic.h" 1
+# 46 "/usr/include/qt4/QtCore/qatomic.h"
+# 1 "/usr/include/qt4/QtCore/qbasicatomic.h" 1
+# 47 "/usr/include/qt4/QtCore/qbasicatomic.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QBasicAtomicInt
+{
+public:
+# 64 "/usr/include/qt4/QtCore/qbasicatomic.h"
+    volatile int _q_value;
+
+
+
+    inline bool operator==(int value) const
+    {
+        return _q_value == value;
+    }
+
+    inline bool operator!=(int value) const
+    {
+        return _q_value != value;
+    }
+
+    inline bool operator!() const
+    {
+        return _q_value == 0;
+    }
+
+    inline operator int() const
+    {
+        return _q_value;
+    }
+
+    inline QBasicAtomicInt &operator=(int value)
+    {
+
+
+
+        _q_value = value;
+        return *this;
+    }
+
+
+
+    static bool isReferenceCountingNative();
+    static bool isReferenceCountingWaitFree();
+
+    bool ref();
+    bool deref();
+
+    static bool isTestAndSetNative();
+    static bool isTestAndSetWaitFree();
+
+    bool testAndSetRelaxed(int expectedValue, int newValue);
+    bool testAndSetAcquire(int expectedValue, int newValue);
+    bool testAndSetRelease(int expectedValue, int newValue);
+    bool testAndSetOrdered(int expectedValue, int newValue);
+
+    static bool isFetchAndStoreNative();
+    static bool isFetchAndStoreWaitFree();
+
+    int fetchAndStoreRelaxed(int newValue);
+    int fetchAndStoreAcquire(int newValue);
+    int fetchAndStoreRelease(int newValue);
+    int fetchAndStoreOrdered(int newValue);
+
+    static bool isFetchAndAddNative();
+    static bool isFetchAndAddWaitFree();
+
+    int fetchAndAddRelaxed(int valueToAdd);
+    int fetchAndAddAcquire(int valueToAdd);
+    int fetchAndAddRelease(int valueToAdd);
+    int fetchAndAddOrdered(int valueToAdd);
+};
+
+template <typename T>
+class QBasicAtomicPointer
+{
+public:
+# 148 "/usr/include/qt4/QtCore/qbasicatomic.h"
+    T * volatile _q_value;
+
+
+
+    inline bool operator==(T *value) const
+    {
+        return _q_value == value;
+    }
+
+    inline bool operator!=(T *value) const
+    {
+        return !operator==(value);
+    }
+
+    inline bool operator!() const
+    {
+        return operator==(0);
+    }
+
+    inline operator T *() const
+    {
+        return _q_value;
+    }
+
+    inline T *operator->() const
+    {
+        return _q_value;
+    }
+
+    inline QBasicAtomicPointer<T> &operator=(T *value)
+    {
+
+
+
+        _q_value = value;
+        return *this;
+    }
+
+
+
+    static bool isTestAndSetNative();
+    static bool isTestAndSetWaitFree();
+
+    bool testAndSetRelaxed(T *expectedValue, T *newValue);
+    bool testAndSetAcquire(T *expectedValue, T *newValue);
+    bool testAndSetRelease(T *expectedValue, T *newValue);
+    bool testAndSetOrdered(T *expectedValue, T *newValue);
+
+    static bool isFetchAndStoreNative();
+    static bool isFetchAndStoreWaitFree();
+
+    T *fetchAndStoreRelaxed(T *newValue);
+    T *fetchAndStoreAcquire(T *newValue);
+    T *fetchAndStoreRelease(T *newValue);
+    T *fetchAndStoreOrdered(T *newValue);
+
+    static bool isFetchAndAddNative();
+    static bool isFetchAndAddWaitFree();
+
+    T *fetchAndAddRelaxed(qptrdiff valueToAdd);
+    T *fetchAndAddAcquire(qptrdiff valueToAdd);
+    T *fetchAndAddRelease(qptrdiff valueToAdd);
+    T *fetchAndAddOrdered(qptrdiff valueToAdd);
+};
+# 221 "/usr/include/qt4/QtCore/qbasicatomic.h"
+
+
+
+
+
+
+# 1 "/usr/include/qt4/QtCore/qatomic_arch.h" 1
+# 45 "/usr/include/qt4/QtCore/qatomic_arch.h"
+
+# 84 "/usr/include/qt4/QtCore/qatomic_arch.h"
+# 1 "/usr/include/qt4/QtCore/qatomic_x86_64.h" 1
+# 45 "/usr/include/qt4/QtCore/qatomic_x86_64.h"
+
+
+
+
+
+
+
+inline bool QBasicAtomicInt::isReferenceCountingNative()
+{ return true; }
+inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
+{ return true; }
+
+
+
+
+inline bool QBasicAtomicInt::isTestAndSetNative()
+{ return true; }
+inline bool QBasicAtomicInt::isTestAndSetWaitFree()
+{ return true; }
+
+
+
+
+inline bool QBasicAtomicInt::isFetchAndStoreNative()
+{ return true; }
+inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
+{ return true; }
+
+
+
+
+inline bool QBasicAtomicInt::isFetchAndAddNative()
+{ return true; }
+inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
+{ return true; }
+
+
+
+
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isTestAndSetNative()
+{ return true; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
+{ return true; }
+
+
+
+
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
+{ return true; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
+{ return true; }
+
+
+
+
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndAddNative()
+{ return true; }
+template <typename T>
+inline bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
+{ return true; }
+
+
+
+inline bool QBasicAtomicInt::ref()
+{
+    unsigned char ret;
+    asm volatile("lock\n"
+                 "incl %0\n"
+                 "setne %1"
+                 : "=m" (_q_value), "=qm" (ret)
+                 : "m" (_q_value)
+                 : "memory");
+    return ret != 0;
+}
+
+inline bool QBasicAtomicInt::deref()
+{
+    unsigned char ret;
+    asm volatile("lock\n"
+                 "decl %0\n"
+                 "setne %1"
+                 : "=m" (_q_value), "=qm" (ret)
+                 : "m" (_q_value)
+                 : "memory");
+    return ret != 0;
+}
+
+inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+{
+    unsigned char ret;
+    asm volatile("lock\n"
+                 "cmpxchgl %3,%2\n"
+                 "sete %1\n"
+                 : "=a" (newValue), "=qm" (ret), "+m" (_q_value)
+                 : "r" (newValue), "0" (expectedValue)
+                 : "memory");
+    return ret != 0;
+}
+
+inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+{
+    asm volatile("xchgl %0,%1"
+                 : "=r" (newValue), "+m" (_q_value)
+                 : "0" (newValue)
+                 : "memory");
+    return newValue;
+}
+
+inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
+{
+    asm volatile("lock\n"
+                 "xaddl %0,%1"
+                 : "=r" (valueToAdd), "+m" (_q_value)
+                 : "0" (valueToAdd)
+                 : "memory");
+    return valueToAdd;
+}
+
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+{
+    unsigned char ret;
+    asm volatile("lock\n"
+                 "cmpxchgq %3,%2\n"
+                 "sete %1\n"
+                 : "=a" (newValue), "=qm" (ret), "+m" (_q_value)
+                 : "r" (newValue), "0" (expectedValue)
+                 : "memory");
+    return ret != 0;
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+{
+    asm volatile("xchgq %0,%1"
+                 : "=r" (newValue), "+m" (_q_value)
+                 : "0" (newValue)
+                 : "memory");
+    return newValue;
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+{
+    asm volatile("lock\n"
+                 "xaddq %0,%1"
+                 : "=r" (valueToAdd), "+m" (_q_value)
+                 : "0" (valueToAdd * sizeof(T))
+                 : "memory");
+    return reinterpret_cast<T *>(valueToAdd);
+}
+# 260 "/usr/include/qt4/QtCore/qatomic_x86_64.h"
+inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+inline bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+{
+    return testAndSetOrdered(expectedValue, newValue);
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+{
+    return fetchAndStoreOrdered(newValue);
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+template <typename T>
+inline T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
+{
+    return fetchAndAddOrdered(valueToAdd);
+}
+
+
+
+
+# 85 "/usr/include/qt4/QtCore/qatomic_arch.h" 2
+# 95 "/usr/include/qt4/QtCore/qatomic_arch.h"
+
+# 228 "/usr/include/qt4/QtCore/qbasicatomic.h" 2
+# 47 "/usr/include/qt4/QtCore/qatomic.h" 2
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+
+class QAtomicInt : public QBasicAtomicInt
+{
+public:
+    inline QAtomicInt(int value = 0)
+    {
+
+
+
+        _q_value = value;
+    }
+    inline QAtomicInt(const QAtomicInt &other)
+    {
+
+
+
+        _q_value = other._q_value;
+    }
+
+    inline QAtomicInt &operator=(int value)
+    {
+        (void) QBasicAtomicInt::operator=(value);
+        return *this;
+    }
+
+    inline QAtomicInt &operator=(const QAtomicInt &other)
+    {
+        (void) QBasicAtomicInt::operator=(other);
+        return *this;
+    }
+# 121 "/usr/include/qt4/QtCore/qatomic.h"
+};
+
+
+template <typename T>
+class QAtomicPointer : public QBasicAtomicPointer<T>
+{
+public:
+    inline QAtomicPointer(T *value = 0)
+    {
+
+
+
+        QBasicAtomicPointer<T>::_q_value = value;
+    }
+    inline QAtomicPointer(const QAtomicPointer<T> &other)
+    {
+
+
+
+        QBasicAtomicPointer<T>::_q_value = other._q_value;
+    }
+
+    inline QAtomicPointer<T> &operator=(T *value)
+    {
+        (void) QBasicAtomicPointer<T>::operator=(value);
+        return *this;
+    }
+
+    inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other)
+    {
+        (void) QBasicAtomicPointer<T>::operator=(other);
+        return *this;
+    }
+# 186 "/usr/include/qt4/QtCore/qatomic.h"
+};
+
+
+
+
+
+
+
+template <typename T>
+inline void qAtomicAssign(T *&d, T *x)
+{
+    if (d == x)
+        return;
+    x->ref.ref();
+    if (!d->ref.deref())
+        delete d;
+    d = x;
+}
+# 213 "/usr/include/qt4/QtCore/qatomic.h"
+template <typename T>
+inline void qAtomicDetach(T *&d)
+{
+    if (d->ref == 1)
+        return;
+    T *x = d;
+    d = new T(*d);
+    if (!x->ref.deref())
+        delete x;
+}
+
+
+
+# 46 "/usr/include/qt4/QtCore/qbytearray.h" 2
+# 1 "/usr/include/qt4/QtCore/qnamespace.h" 1
+# 47 "/usr/include/qt4/QtCore/qnamespace.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+
+namespace
+
+
+
+Qt {
+# 99 "/usr/include/qt4/QtCore/qnamespace.h"
+    enum GlobalColor {
+        color0,
+        color1,
+        black,
+        white,
+        darkGray,
+        gray,
+        lightGray,
+        red,
+        green,
+        blue,
+        cyan,
+        magenta,
+        yellow,
+        darkRed,
+        darkGreen,
+        darkBlue,
+        darkCyan,
+        darkMagenta,
+        darkYellow,
+        transparent
+    };
+
+    enum KeyboardModifier {
+        NoModifier = 0x00000000,
+        ShiftModifier = 0x02000000,
+        ControlModifier = 0x04000000,
+        AltModifier = 0x08000000,
+        MetaModifier = 0x10000000,
+        KeypadModifier = 0x20000000,
+        GroupSwitchModifier = 0x40000000,
+
+        KeyboardModifierMask = 0xfe000000
+    };
+    typedef QFlags<KeyboardModifier> KeyboardModifiers;
+
+
+    enum Modifier {
+        META = Qt::MetaModifier,
+        SHIFT = Qt::ShiftModifier,
+        CTRL = Qt::ControlModifier,
+        ALT = Qt::AltModifier,
+        MODIFIER_MASK = KeyboardModifierMask,
+        UNICODE_ACCEL = 0x00000000
+    };
+
+    enum MouseButton {
+        NoButton = 0x00000000,
+        LeftButton = 0x00000001,
+        RightButton = 0x00000002,
+        MidButton = 0x00000004,
+        XButton1 = 0x00000008,
+        XButton2 = 0x00000010,
+        MouseButtonMask = 0x000000ff
+    };
+    typedef QFlags<MouseButton> MouseButtons;
+# 168 "/usr/include/qt4/QtCore/qnamespace.h"
+    enum Orientation {
+        Horizontal = 0x1,
+        Vertical = 0x2
+    };
+
+    typedef QFlags<Orientation> Orientations;
+
+    enum FocusPolicy {
+        NoFocus = 0,
+        TabFocus = 0x1,
+        ClickFocus = 0x2,
+        StrongFocus = TabFocus | ClickFocus | 0x8,
+        WheelFocus = StrongFocus | 0x4
+    };
+
+    enum SortOrder {
+        AscendingOrder,
+        DescendingOrder
+
+
+
+
+    };
+
+    enum TileRule {
+        StretchTile,
+        RepeatTile,
+        RoundTile
+    };
+
+
+
+
+
+    enum AlignmentFlag {
+        AlignLeft = 0x0001,
+        AlignLeading = AlignLeft,
+        AlignRight = 0x0002,
+        AlignTrailing = AlignRight,
+        AlignHCenter = 0x0004,
+        AlignJustify = 0x0008,
+        AlignAbsolute = 0x0010,
+        AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute,
+
+        AlignTop = 0x0020,
+        AlignBottom = 0x0040,
+        AlignVCenter = 0x0080,
+        AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter,
+
+        AlignCenter = AlignVCenter | AlignHCenter
+
+
+
+    };
+
+    typedef QFlags<AlignmentFlag> Alignment;
+
+    enum TextFlag {
+        TextSingleLine = 0x0100,
+        TextDontClip = 0x0200,
+        TextExpandTabs = 0x0400,
+        TextShowMnemonic = 0x0800,
+        TextWordWrap = 0x1000,
+        TextWrapAnywhere = 0x2000,
+        TextDontPrint = 0x4000,
+        TextIncludeTrailingSpaces = 0x08000000,
+        TextHideMnemonic = 0x8000,
+        TextJustificationForced = 0x10000,
+        TextForceLeftToRight = 0x20000,
+        TextForceRightToLeft = 0x40000,
+        TextLongestVariant = 0x80000
+# 251 "/usr/include/qt4/QtCore/qnamespace.h"
+    };
+
+
+
+
+    enum TextElideMode {
+        ElideLeft,
+        ElideRight,
+        ElideMiddle,
+        ElideNone
+    };
+
+    enum WindowType {
+        Widget = 0x00000000,
+        Window = 0x00000001,
+        Dialog = 0x00000002 | Window,
+        Sheet = 0x00000004 | Window,
+        Drawer = 0x00000006 | Window,
+        Popup = 0x00000008 | Window,
+        Tool = 0x0000000a | Window,
+        ToolTip = 0x0000000c | Window,
+        SplashScreen = 0x0000000e | Window,
+        Desktop = 0x00000010 | Window,
+        SubWindow = 0x00000012,
+
+        WindowType_Mask = 0x000000ff,
+        MSWindowsFixedSizeDialogHint = 0x00000100,
+        MSWindowsOwnDC = 0x00000200,
+        X11BypassWindowManagerHint = 0x00000400,
+        FramelessWindowHint = 0x00000800,
+        WindowTitleHint = 0x00001000,
+        WindowSystemMenuHint = 0x00002000,
+        WindowMinimizeButtonHint = 0x00004000,
+        WindowMaximizeButtonHint = 0x00008000,
+        WindowMinMaxButtonsHint = WindowMinimizeButtonHint | WindowMaximizeButtonHint,
+        WindowContextHelpButtonHint = 0x00010000,
+        WindowShadeButtonHint = 0x00020000,
+        WindowStaysOnTopHint = 0x00040000,
+
+
+
+
+
+
+
+        CustomizeWindowHint = 0x02000000,
+        WindowStaysOnBottomHint = 0x04000000,
+        WindowCloseButtonHint = 0x08000000,
+        MacWindowToolBarButtonHint = 0x10000000,
+        BypassGraphicsProxyWidget = 0x20000000,
+        WindowOkButtonHint = 0x00080000,
+        WindowCancelButtonHint = 0x00100000
+# 353 "/usr/include/qt4/QtCore/qnamespace.h"
+    };
+
+    typedef QFlags<WindowType> WindowFlags;
+
+    enum WindowState {
+        WindowNoState = 0x00000000,
+        WindowMinimized = 0x00000001,
+        WindowMaximized = 0x00000002,
+        WindowFullScreen = 0x00000004,
+        WindowActive = 0x00000008
+    };
+
+    typedef QFlags<WindowState> WindowStates;
+
+    enum WidgetAttribute {
+        WA_Disabled = 0,
+        WA_UnderMouse = 1,
+        WA_MouseTracking = 2,
+        WA_ContentsPropagated = 3,
+        WA_OpaquePaintEvent = 4,
+        WA_NoBackground = WA_OpaquePaintEvent,
+        WA_StaticContents = 5,
+        WA_LaidOut = 7,
+        WA_PaintOnScreen = 8,
+        WA_NoSystemBackground = 9,
+        WA_UpdatesDisabled = 10,
+        WA_Mapped = 11,
+        WA_MacNoClickThrough = 12,
+        WA_PaintOutsidePaintEvent = 13,
+        WA_InputMethodEnabled = 14,
+        WA_WState_Visible = 15,
+        WA_WState_Hidden = 16,
+
+        WA_ForceDisabled = 32,
+        WA_KeyCompression = 33,
+        WA_PendingMoveEvent = 34,
+        WA_PendingResizeEvent = 35,
+        WA_SetPalette = 36,
+        WA_SetFont = 37,
+        WA_SetCursor = 38,
+        WA_NoChildEventsFromChildren = 39,
+        WA_WindowModified = 41,
+        WA_Resized = 42,
+        WA_Moved = 43,
+        WA_PendingUpdate = 44,
+        WA_InvalidSize = 45,
+        WA_MacBrushedMetal = 46,
+        WA_MacMetalStyle = WA_MacBrushedMetal,
+        WA_CustomWhatsThis = 47,
+        WA_LayoutOnEntireRect = 48,
+        WA_OutsideWSRange = 49,
+        WA_GrabbedShortcut = 50,
+        WA_TransparentForMouseEvents = 51,
+        WA_PaintUnclipped = 52,
+        WA_SetWindowIcon = 53,
+        WA_NoMouseReplay = 54,
+        WA_DeleteOnClose = 55,
+        WA_RightToLeft = 56,
+        WA_SetLayoutDirection = 57,
+        WA_NoChildEventsForParent = 58,
+        WA_ForceUpdatesDisabled = 59,
+
+        WA_WState_Created = 60,
+        WA_WState_CompressKeys = 61,
+        WA_WState_InPaintEvent = 62,
+        WA_WState_Reparented = 63,
+        WA_WState_ConfigPending = 64,
+        WA_WState_Polished = 66,
+        WA_WState_DND = 67,
+        WA_WState_OwnSizePolicy = 68,
+        WA_WState_ExplicitShowHide = 69,
+
+        WA_ShowModal = 70,
+        WA_MouseNoMask = 71,
+        WA_GroupLeader = 72,
+        WA_NoMousePropagation = 73,
+        WA_Hover = 74,
+        WA_InputMethodTransparent = 75,
+        WA_QuitOnClose = 76,
+
+        WA_KeyboardFocusChange = 77,
+
+        WA_AcceptDrops = 78,
+        WA_DropSiteRegistered = 79,
+        WA_ForceAcceptDrops = WA_DropSiteRegistered,
+
+        WA_WindowPropagation = 80,
+
+        WA_NoX11EventCompression = 81,
+        WA_TintedBackground = 82,
+        WA_X11OpenGLOverlay = 83,
+        WA_AlwaysShowToolTips = 84,
+        WA_MacOpaqueSizeGrip = 85,
+        WA_SetStyle = 86,
+
+        WA_SetLocale = 87,
+        WA_MacShowFocusRect = 88,
+
+        WA_MacNormalSize = 89,
+        WA_MacSmallSize = 90,
+        WA_MacMiniSize = 91,
+
+        WA_LayoutUsesWidgetRect = 92,
+        WA_StyledBackground = 93,
+        WA_MSWindowsUseDirect3D = 94,
+        WA_CanHostQMdiSubWindowTitleBar = 95,
+
+        WA_MacAlwaysShowToolWindow = 96,
+
+        WA_StyleSheet = 97,
+
+        WA_ShowWithoutActivating = 98,
+
+        WA_X11BypassTransientForHint = 99,
+
+        WA_NativeWindow = 100,
+        WA_DontCreateNativeAncestors = 101,
+
+        WA_MacVariableSize = 102,
+
+        WA_DontShowOnScreen = 103,
+
+
+        WA_X11NetWmWindowTypeDesktop = 104,
+        WA_X11NetWmWindowTypeDock = 105,
+        WA_X11NetWmWindowTypeToolBar = 106,
+        WA_X11NetWmWindowTypeMenu = 107,
+        WA_X11NetWmWindowTypeUtility = 108,
+        WA_X11NetWmWindowTypeSplash = 109,
+        WA_X11NetWmWindowTypeDialog = 110,
+        WA_X11NetWmWindowTypeDropDownMenu = 111,
+        WA_X11NetWmWindowTypePopupMenu = 112,
+        WA_X11NetWmWindowTypeToolTip = 113,
+        WA_X11NetWmWindowTypeNotification = 114,
+        WA_X11NetWmWindowTypeCombo = 115,
+        WA_X11NetWmWindowTypeDND = 116,
+
+        WA_MacFrameworkScaled = 117,
+
+        WA_SetWindowModality = 118,
+        WA_WState_WindowOpacitySet = 119,
+        WA_TranslucentBackground = 120,
+
+        WA_AcceptTouchEvents = 121,
+        WA_WState_AcceptedTouchBeginEvent = 122,
+        WA_TouchPadAcceptSingleTouchEvents = 123,
+
+        WA_MergeSoftkeys = 124,
+        WA_MergeSoftkeysRecursively = 125,
+
+
+        WA_AttributeCount
+    };
+
+    enum ApplicationAttribute
+    {
+        AA_ImmediateWidgetCreation = 0,
+        AA_MSWindowsUseDirect3DByDefault = 1,
+        AA_DontShowIconsInMenus = 2,
+        AA_NativeWindows = 3,
+        AA_DontCreateNativeWidgetSiblings = 4,
+        AA_MacPluginApplication = 5,
+        AA_DontUseNativeMenuBar = 6,
+        AA_MacDontSwapCtrlAndMeta = 7,
+        AA_S60DontConstructApplicationPanes = 8,
+
+
+        AA_AttributeCount
+    };
+
+
+
+
+
+    enum ImageConversionFlag {
+        ColorMode_Mask = 0x00000003,
+        AutoColor = 0x00000000,
+        ColorOnly = 0x00000003,
+        MonoOnly = 0x00000002,
+
+
+        AlphaDither_Mask = 0x0000000c,
+        ThresholdAlphaDither = 0x00000000,
+        OrderedAlphaDither = 0x00000004,
+        DiffuseAlphaDither = 0x00000008,
+        NoAlpha = 0x0000000c,
+
+        Dither_Mask = 0x00000030,
+        DiffuseDither = 0x00000000,
+        OrderedDither = 0x00000010,
+        ThresholdDither = 0x00000020,
+
+
+        DitherMode_Mask = 0x000000c0,
+        AutoDither = 0x00000000,
+        PreferDither = 0x00000040,
+        AvoidDither = 0x00000080,
+
+        NoOpaqueDetection = 0x00000100
+    };
+    typedef QFlags<ImageConversionFlag> ImageConversionFlags;
+
+    enum BGMode {
+        TransparentMode,
+        OpaqueMode
+    };
+# 579 "/usr/include/qt4/QtCore/qnamespace.h"
+    enum Key {
+        Key_Escape = 0x01000000,
+        Key_Tab = 0x01000001,
+        Key_Backtab = 0x01000002,
+
+
+
+        Key_Backspace = 0x01000003,
+
+
+
+        Key_Return = 0x01000004,
+        Key_Enter = 0x01000005,
+        Key_Insert = 0x01000006,
+        Key_Delete = 0x01000007,
+        Key_Pause = 0x01000008,
+        Key_Print = 0x01000009,
+        Key_SysReq = 0x0100000a,
+        Key_Clear = 0x0100000b,
+        Key_Home = 0x01000010,
+        Key_End = 0x01000011,
+        Key_Left = 0x01000012,
+        Key_Up = 0x01000013,
+        Key_Right = 0x01000014,
+        Key_Down = 0x01000015,
+        Key_PageUp = 0x01000016,
+
+
+
+        Key_PageDown = 0x01000017,
+
+
+
+        Key_Shift = 0x01000020,
+        Key_Control = 0x01000021,
+        Key_Meta = 0x01000022,
+        Key_Alt = 0x01000023,
+        Key_CapsLock = 0x01000024,
+        Key_NumLock = 0x01000025,
+        Key_ScrollLock = 0x01000026,
+        Key_F1 = 0x01000030,
+        Key_F2 = 0x01000031,
+        Key_F3 = 0x01000032,
+        Key_F4 = 0x01000033,
+        Key_F5 = 0x01000034,
+        Key_F6 = 0x01000035,
+        Key_F7 = 0x01000036,
+        Key_F8 = 0x01000037,
+        Key_F9 = 0x01000038,
+        Key_F10 = 0x01000039,
+        Key_F11 = 0x0100003a,
+        Key_F12 = 0x0100003b,
+        Key_F13 = 0x0100003c,
+        Key_F14 = 0x0100003d,
+        Key_F15 = 0x0100003e,
+        Key_F16 = 0x0100003f,
+        Key_F17 = 0x01000040,
+        Key_F18 = 0x01000041,
+        Key_F19 = 0x01000042,
+        Key_F20 = 0x01000043,
+        Key_F21 = 0x01000044,
+        Key_F22 = 0x01000045,
+        Key_F23 = 0x01000046,
+        Key_F24 = 0x01000047,
+        Key_F25 = 0x01000048,
+        Key_F26 = 0x01000049,
+        Key_F27 = 0x0100004a,
+        Key_F28 = 0x0100004b,
+        Key_F29 = 0x0100004c,
+        Key_F30 = 0x0100004d,
+        Key_F31 = 0x0100004e,
+        Key_F32 = 0x0100004f,
+        Key_F33 = 0x01000050,
+        Key_F34 = 0x01000051,
+        Key_F35 = 0x01000052,
+        Key_Super_L = 0x01000053,
+        Key_Super_R = 0x01000054,
+        Key_Menu = 0x01000055,
+        Key_Hyper_L = 0x01000056,
+        Key_Hyper_R = 0x01000057,
+        Key_Help = 0x01000058,
+        Key_Direction_L = 0x01000059,
+        Key_Direction_R = 0x01000060,
+        Key_Space = 0x20,
+        Key_Any = Key_Space,
+        Key_Exclam = 0x21,
+        Key_QuoteDbl = 0x22,
+        Key_NumberSign = 0x23,
+        Key_Dollar = 0x24,
+        Key_Percent = 0x25,
+        Key_Ampersand = 0x26,
+        Key_Apostrophe = 0x27,
+        Key_ParenLeft = 0x28,
+        Key_ParenRight = 0x29,
+        Key_Asterisk = 0x2a,
+        Key_Plus = 0x2b,
+        Key_Comma = 0x2c,
+        Key_Minus = 0x2d,
+        Key_Period = 0x2e,
+        Key_Slash = 0x2f,
+        Key_0 = 0x30,
+        Key_1 = 0x31,
+        Key_2 = 0x32,
+        Key_3 = 0x33,
+        Key_4 = 0x34,
+        Key_5 = 0x35,
+        Key_6 = 0x36,
+        Key_7 = 0x37,
+        Key_8 = 0x38,
+        Key_9 = 0x39,
+        Key_Colon = 0x3a,
+        Key_Semicolon = 0x3b,
+        Key_Less = 0x3c,
+        Key_Equal = 0x3d,
+        Key_Greater = 0x3e,
+        Key_Question = 0x3f,
+        Key_At = 0x40,
+        Key_A = 0x41,
+        Key_B = 0x42,
+        Key_C = 0x43,
+        Key_D = 0x44,
+        Key_E = 0x45,
+        Key_F = 0x46,
+        Key_G = 0x47,
+        Key_H = 0x48,
+        Key_I = 0x49,
+        Key_J = 0x4a,
+        Key_K = 0x4b,
+        Key_L = 0x4c,
+        Key_M = 0x4d,
+        Key_N = 0x4e,
+        Key_O = 0x4f,
+        Key_P = 0x50,
+        Key_Q = 0x51,
+        Key_R = 0x52,
+        Key_S = 0x53,
+        Key_T = 0x54,
+        Key_U = 0x55,
+        Key_V = 0x56,
+        Key_W = 0x57,
+        Key_X = 0x58,
+        Key_Y = 0x59,
+        Key_Z = 0x5a,
+        Key_BracketLeft = 0x5b,
+        Key_Backslash = 0x5c,
+        Key_BracketRight = 0x5d,
+        Key_AsciiCircum = 0x5e,
+        Key_Underscore = 0x5f,
+        Key_QuoteLeft = 0x60,
+        Key_BraceLeft = 0x7b,
+        Key_Bar = 0x7c,
+        Key_BraceRight = 0x7d,
+        Key_AsciiTilde = 0x7e,
+
+        Key_nobreakspace = 0x0a0,
+        Key_exclamdown = 0x0a1,
+        Key_cent = 0x0a2,
+        Key_sterling = 0x0a3,
+        Key_currency = 0x0a4,
+        Key_yen = 0x0a5,
+        Key_brokenbar = 0x0a6,
+        Key_section = 0x0a7,
+        Key_diaeresis = 0x0a8,
+        Key_copyright = 0x0a9,
+        Key_ordfeminine = 0x0aa,
+        Key_guillemotleft = 0x0ab,
+        Key_notsign = 0x0ac,
+        Key_hyphen = 0x0ad,
+        Key_registered = 0x0ae,
+        Key_macron = 0x0af,
+        Key_degree = 0x0b0,
+        Key_plusminus = 0x0b1,
+        Key_twosuperior = 0x0b2,
+        Key_threesuperior = 0x0b3,
+        Key_acute = 0x0b4,
+        Key_mu = 0x0b5,
+        Key_paragraph = 0x0b6,
+        Key_periodcentered = 0x0b7,
+        Key_cedilla = 0x0b8,
+        Key_onesuperior = 0x0b9,
+        Key_masculine = 0x0ba,
+        Key_guillemotright = 0x0bb,
+        Key_onequarter = 0x0bc,
+        Key_onehalf = 0x0bd,
+        Key_threequarters = 0x0be,
+        Key_questiondown = 0x0bf,
+        Key_Agrave = 0x0c0,
+        Key_Aacute = 0x0c1,
+        Key_Acircumflex = 0x0c2,
+        Key_Atilde = 0x0c3,
+        Key_Adiaeresis = 0x0c4,
+        Key_Aring = 0x0c5,
+        Key_AE = 0x0c6,
+        Key_Ccedilla = 0x0c7,
+        Key_Egrave = 0x0c8,
+        Key_Eacute = 0x0c9,
+        Key_Ecircumflex = 0x0ca,
+        Key_Ediaeresis = 0x0cb,
+        Key_Igrave = 0x0cc,
+        Key_Iacute = 0x0cd,
+        Key_Icircumflex = 0x0ce,
+        Key_Idiaeresis = 0x0cf,
+        Key_ETH = 0x0d0,
+        Key_Ntilde = 0x0d1,
+        Key_Ograve = 0x0d2,
+        Key_Oacute = 0x0d3,
+        Key_Ocircumflex = 0x0d4,
+        Key_Otilde = 0x0d5,
+        Key_Odiaeresis = 0x0d6,
+        Key_multiply = 0x0d7,
+        Key_Ooblique = 0x0d8,
+        Key_Ugrave = 0x0d9,
+        Key_Uacute = 0x0da,
+        Key_Ucircumflex = 0x0db,
+        Key_Udiaeresis = 0x0dc,
+        Key_Yacute = 0x0dd,
+        Key_THORN = 0x0de,
+        Key_ssharp = 0x0df,
+# 822 "/usr/include/qt4/QtCore/qnamespace.h"
+        Key_division = 0x0f7,
+# 832 "/usr/include/qt4/QtCore/qnamespace.h"
+        Key_ydiaeresis = 0x0ff,
+
+
+
+
+
+
+        Key_AltGr = 0x01001103,
+        Key_Multi_key = 0x01001120,
+        Key_Codeinput = 0x01001137,
+        Key_SingleCandidate = 0x0100113c,
+        Key_MultipleCandidate = 0x0100113d,
+        Key_PreviousCandidate = 0x0100113e,
+
+
+        Key_Mode_switch = 0x0100117e,
+
+
+
+        Key_Kanji = 0x01001121,
+        Key_Muhenkan = 0x01001122,
+
+        Key_Henkan = 0x01001123,
+        Key_Romaji = 0x01001124,
+        Key_Hiragana = 0x01001125,
+        Key_Katakana = 0x01001126,
+        Key_Hiragana_Katakana = 0x01001127,
+        Key_Zenkaku = 0x01001128,
+        Key_Hankaku = 0x01001129,
+        Key_Zenkaku_Hankaku = 0x0100112a,
+        Key_Touroku = 0x0100112b,
+        Key_Massyo = 0x0100112c,
+        Key_Kana_Lock = 0x0100112d,
+        Key_Kana_Shift = 0x0100112e,
+        Key_Eisu_Shift = 0x0100112f,
+        Key_Eisu_toggle = 0x01001130,
+# 877 "/usr/include/qt4/QtCore/qnamespace.h"
+        Key_Hangul = 0x01001131,
+        Key_Hangul_Start = 0x01001132,
+        Key_Hangul_End = 0x01001133,
+        Key_Hangul_Hanja = 0x01001134,
+        Key_Hangul_Jamo = 0x01001135,
+        Key_Hangul_Romaja = 0x01001136,
+
+        Key_Hangul_Jeonja = 0x01001138,
+        Key_Hangul_Banja = 0x01001139,
+        Key_Hangul_PreHanja = 0x0100113a,
+        Key_Hangul_PostHanja = 0x0100113b,
+
+
+
+        Key_Hangul_Special = 0x0100113f,
+
+
+
+        Key_Dead_Grave = 0x01001250,
+        Key_Dead_Acute = 0x01001251,
+        Key_Dead_Circumflex = 0x01001252,
+        Key_Dead_Tilde = 0x01001253,
+        Key_Dead_Macron = 0x01001254,
+        Key_Dead_Breve = 0x01001255,
+        Key_Dead_Abovedot = 0x01001256,
+        Key_Dead_Diaeresis = 0x01001257,
+        Key_Dead_Abovering = 0x01001258,
+        Key_Dead_Doubleacute = 0x01001259,
+        Key_Dead_Caron = 0x0100125a,
+        Key_Dead_Cedilla = 0x0100125b,
+        Key_Dead_Ogonek = 0x0100125c,
+        Key_Dead_Iota = 0x0100125d,
+        Key_Dead_Voiced_Sound = 0x0100125e,
+        Key_Dead_Semivoiced_Sound = 0x0100125f,
+        Key_Dead_Belowdot = 0x01001260,
+        Key_Dead_Hook = 0x01001261,
+        Key_Dead_Horn = 0x01001262,
+
+
+        Key_Back = 0x01000061,
+        Key_Forward = 0x01000062,
+        Key_Stop = 0x01000063,
+        Key_Refresh = 0x01000064,
+        Key_VolumeDown = 0x01000070,
+        Key_VolumeMute = 0x01000071,
+        Key_VolumeUp = 0x01000072,
+        Key_BassBoost = 0x01000073,
+        Key_BassUp = 0x01000074,
+        Key_BassDown = 0x01000075,
+        Key_TrebleUp = 0x01000076,
+        Key_TrebleDown = 0x01000077,
+        Key_MediaPlay = 0x01000080,
+        Key_MediaStop = 0x01000081,
+        Key_MediaPrevious = 0x01000082,
+
+
+
+        Key_MediaNext = 0x01000083,
+        Key_MediaRecord = 0x01000084,
+        Key_HomePage = 0x01000090,
+        Key_Favorites = 0x01000091,
+        Key_Search = 0x01000092,
+        Key_Standby = 0x01000093,
+        Key_OpenUrl = 0x01000094,
+        Key_LaunchMail = 0x010000a0,
+        Key_LaunchMedia = 0x010000a1,
+        Key_Launch0 = 0x010000a2,
+        Key_Launch1 = 0x010000a3,
+        Key_Launch2 = 0x010000a4,
+        Key_Launch3 = 0x010000a5,
+        Key_Launch4 = 0x010000a6,
+        Key_Launch5 = 0x010000a7,
+        Key_Launch6 = 0x010000a8,
+        Key_Launch7 = 0x010000a9,
+        Key_Launch8 = 0x010000aa,
+        Key_Launch9 = 0x010000ab,
+        Key_LaunchA = 0x010000ac,
+        Key_LaunchB = 0x010000ad,
+        Key_LaunchC = 0x010000ae,
+        Key_LaunchD = 0x010000af,
+        Key_LaunchE = 0x010000b0,
+        Key_LaunchF = 0x010000b1,
+        Key_MonBrightnessUp = 0x010000b2,
+        Key_MonBrightnessDown = 0x010000b3,
+        Key_KeyboardLightOnOff = 0x010000b4,
+        Key_KeyboardBrightnessUp = 0x010000b5,
+        Key_KeyboardBrightnessDown = 0x010000b6,
+        Key_PowerOff = 0x010000b7,
+        Key_WakeUp = 0x010000b8,
+        Key_Eject = 0x010000b9,
+        Key_ScreenSaver = 0x010000ba,
+        Key_WWW = 0x010000bb,
+        Key_Memo = 0x010000bc,
+        Key_LightBulb = 0x010000bd,
+        Key_Shop = 0x010000be,
+        Key_History = 0x010000bf,
+        Key_AddFavorite = 0x010000c0,
+        Key_HotLinks = 0x010000c1,
+        Key_BrightnessAdjust = 0x010000c2,
+        Key_Finance = 0x010000c3,
+        Key_Community = 0x010000c4,
+        Key_AudioRewind = 0x010000c5,
+        Key_BackForward = 0x010000c6,
+        Key_ApplicationLeft = 0x010000c7,
+        Key_ApplicationRight = 0x010000c8,
+        Key_Book = 0x010000c9,
+        Key_CD = 0x010000ca,
+        Key_Calculator = 0x010000cb,
+        Key_ToDoList = 0x010000cc,
+        Key_ClearGrab = 0x010000cd,
+        Key_Close = 0x010000ce,
+        Key_Copy = 0x010000cf,
+        Key_Cut = 0x010000d0,
+        Key_Display = 0x010000d1,
+        Key_DOS = 0x010000d2,
+        Key_Documents = 0x010000d3,
+        Key_Excel = 0x010000d4,
+        Key_Explorer = 0x010000d5,
+        Key_Game = 0x010000d6,
+        Key_Go = 0x010000d7,
+        Key_iTouch = 0x010000d8,
+        Key_LogOff = 0x010000d9,
+        Key_Market = 0x010000da,
+        Key_Meeting = 0x010000db,
+        Key_MenuKB = 0x010000dc,
+        Key_MenuPB = 0x010000dd,
+        Key_MySites = 0x010000de,
+        Key_News = 0x010000df,
+        Key_OfficeHome = 0x010000e0,
+        Key_Option = 0x010000e1,
+        Key_Paste = 0x010000e2,
+        Key_Phone = 0x010000e3,
+        Key_Calendar = 0x010000e4,
+        Key_Reply = 0x010000e5,
+        Key_Reload = 0x010000e6,
+        Key_RotateWindows = 0x010000e7,
+        Key_RotationPB = 0x010000e8,
+        Key_RotationKB = 0x010000e9,
+        Key_Save = 0x010000ea,
+        Key_Send = 0x010000eb,
+        Key_Spell = 0x010000ec,
+        Key_SplitScreen = 0x010000ed,
+        Key_Support = 0x010000ee,
+        Key_TaskPane = 0x010000ef,
+        Key_Terminal = 0x010000f0,
+        Key_Tools = 0x010000f1,
+        Key_Travel = 0x010000f2,
+        Key_Video = 0x010000f3,
+        Key_Word = 0x010000f4,
+        Key_Xfer = 0x010000f5,
+        Key_ZoomIn = 0x010000f6,
+        Key_ZoomOut = 0x010000f7,
+        Key_Away = 0x010000f8,
+        Key_Messenger = 0x010000f9,
+        Key_WebCam = 0x010000fa,
+        Key_MailForward = 0x010000fb,
+        Key_Pictures = 0x010000fc,
+        Key_Music = 0x010000fd,
+        Key_Battery = 0x010000fe,
+        Key_Bluetooth = 0x010000ff,
+        Key_WLAN = 0x01000100,
+        Key_UWB = 0x01000101,
+        Key_AudioForward = 0x01000102,
+        Key_AudioRepeat = 0x01000103,
+        Key_AudioRandomPlay = 0x01000104,
+        Key_Subtitle = 0x01000105,
+        Key_AudioCycleTrack = 0x01000106,
+        Key_Time = 0x01000107,
+        Key_Hibernate = 0x01000108,
+        Key_View = 0x01000109,
+        Key_TopMenu = 0x0100010a,
+        Key_PowerDown = 0x0100010b,
+        Key_Suspend = 0x0100010c,
+        Key_ContrastAdjust = 0x0100010d,
+
+        Key_MediaLast = 0x0100ffff,
+
+
+        Key_Select = 0x01010000,
+        Key_Yes = 0x01010001,
+        Key_No = 0x01010002,
+
+
+        Key_Cancel = 0x01020001,
+        Key_Printer = 0x01020002,
+        Key_Execute = 0x01020003,
+        Key_Sleep = 0x01020004,
+        Key_Play = 0x01020005,
+        Key_Zoom = 0x01020006,
+
+
+
+
+
+        Key_Context1 = 0x01100000,
+        Key_Context2 = 0x01100001,
+        Key_Context3 = 0x01100002,
+        Key_Context4 = 0x01100003,
+        Key_Call = 0x01100004,
+        Key_Hangup = 0x01100005,
+        Key_Flip = 0x01100006,
+
+        Key_unknown = 0x01ffffff
+    };
+
+    enum ArrowType {
+        NoArrow,
+        UpArrow,
+        DownArrow,
+        LeftArrow,
+        RightArrow
+    };
+
+    enum PenStyle {
+        NoPen,
+        SolidLine,
+        DashLine,
+        DotLine,
+        DashDotLine,
+        DashDotDotLine,
+        CustomDashLine
+
+        , MPenStyle = 0x0f
+
+    };
+
+    enum PenCapStyle {
+        FlatCap = 0x00,
+        SquareCap = 0x10,
+        RoundCap = 0x20,
+        MPenCapStyle = 0x30
+    };
+
+    enum PenJoinStyle {
+        MiterJoin = 0x00,
+        BevelJoin = 0x40,
+        RoundJoin = 0x80,
+        SvgMiterJoin = 0x100,
+        MPenJoinStyle = 0x1c0
+    };
+
+    enum BrushStyle {
+        NoBrush,
+        SolidPattern,
+        Dense1Pattern,
+        Dense2Pattern,
+        Dense3Pattern,
+        Dense4Pattern,
+        Dense5Pattern,
+        Dense6Pattern,
+        Dense7Pattern,
+        HorPattern,
+        VerPattern,
+        CrossPattern,
+        BDiagPattern,
+        FDiagPattern,
+        DiagCrossPattern,
+        LinearGradientPattern,
+        RadialGradientPattern,
+        ConicalGradientPattern,
+        TexturePattern = 24
+
+
+
+    };
+
+    enum SizeMode {
+        AbsoluteSize,
+        RelativeSize
+    };
+# 1208 "/usr/include/qt4/QtCore/qnamespace.h"
+    enum UIEffect {
+        UI_General,
+        UI_AnimateMenu,
+        UI_FadeMenu,
+        UI_AnimateCombo,
+        UI_AnimateTooltip,
+        UI_FadeTooltip,
+        UI_AnimateToolBox
+    };
+
+    enum CursorShape {
+        ArrowCursor,
+        UpArrowCursor,
+        CrossCursor,
+        WaitCursor,
+        IBeamCursor,
+        SizeVerCursor,
+        SizeHorCursor,
+        SizeBDiagCursor,
+        SizeFDiagCursor,
+        SizeAllCursor,
+        BlankCursor,
+        SplitVCursor,
+        SplitHCursor,
+        PointingHandCursor,
+        ForbiddenCursor,
+        WhatsThisCursor,
+        BusyCursor,
+        OpenHandCursor,
+        ClosedHandCursor,
+        LastCursor = ClosedHandCursor,
+        BitmapCursor = 24,
+        CustomCursor = 25
+# 1261 "/usr/include/qt4/QtCore/qnamespace.h"
+    };
+
+    enum TextFormat {
+        PlainText,
+        RichText,
+        AutoText,
+        LogText
+    };
+
+    enum AspectRatioMode {
+        IgnoreAspectRatio,
+        KeepAspectRatio,
+        KeepAspectRatioByExpanding
+
+
+
+
+
+    };
+
+
+
+
+
+    enum AnchorAttribute {
+        AnchorName,
+        AnchorHref
+    };
+
+    enum DockWidgetArea {
+        LeftDockWidgetArea = 0x1,
+        RightDockWidgetArea = 0x2,
+        TopDockWidgetArea = 0x4,
+        BottomDockWidgetArea = 0x8,
+
+        DockWidgetArea_Mask = 0xf,
+        AllDockWidgetAreas = DockWidgetArea_Mask,
+        NoDockWidgetArea = 0
+    };
+    enum DockWidgetAreaSizes {
+        NDockWidgetAreas = 4
+    };
+
+    typedef QFlags<DockWidgetArea> DockWidgetAreas;
+
+    enum ToolBarArea {
+        LeftToolBarArea = 0x1,
+        RightToolBarArea = 0x2,
+        TopToolBarArea = 0x4,
+        BottomToolBarArea = 0x8,
+
+        ToolBarArea_Mask = 0xf,
+        AllToolBarAreas = ToolBarArea_Mask,
+        NoToolBarArea = 0
+    };
+
+    enum ToolBarAreaSizes {
+        NToolBarAreas = 4
+    };
+
+    typedef QFlags<ToolBarArea> ToolBarAreas;
+# 1345 "/usr/include/qt4/QtCore/qnamespace.h"
+    enum DateFormat {
+        TextDate,
+        ISODate,
+        SystemLocaleDate,
+        LocalDate = SystemLocaleDate,
+        LocaleDate,
+        SystemLocaleShortDate,
+        SystemLocaleLongDate,
+        DefaultLocaleShortDate,
+        DefaultLocaleLongDate
+    };
+
+    enum TimeSpec {
+        LocalTime,
+        UTC,
+        OffsetFromUTC
+    };
+
+    enum DayOfWeek {
+        Monday = 1,
+        Tuesday = 2,
+        Wednesday = 3,
+        Thursday = 4,
+        Friday = 5,
+        Saturday = 6,
+        Sunday = 7
+    };
+
+    enum ScrollBarPolicy {
+        ScrollBarAsNeeded,
+        ScrollBarAlwaysOff,
+        ScrollBarAlwaysOn
+    };
+# 1404 "/usr/include/qt4/QtCore/qnamespace.h"
+    enum CaseSensitivity {
+        CaseInsensitive,
+        CaseSensitive
+    };
+
+    enum Corner {
+        TopLeftCorner = 0x00000,
+        TopRightCorner = 0x00001,
+        BottomLeftCorner = 0x00002,
+        BottomRightCorner = 0x00003
+
+
+
+
+
+
+    };
+
+    enum ConnectionType {
+        AutoConnection,
+        DirectConnection,
+        QueuedConnection,
+        AutoCompatConnection,
+        BlockingQueuedConnection,
+        UniqueConnection = 0x80
+    };
+
+    enum ShortcutContext {
+        WidgetShortcut,
+        WindowShortcut,
+        ApplicationShortcut,
+        WidgetWithChildrenShortcut
+    };
+
+    enum FillRule {
+        OddEvenFill,
+        WindingFill
+    };
+
+    enum MaskMode {
+        MaskInColor,
+        MaskOutColor
+    };
+
+    enum ClipOperation {
+        NoClip,
+        ReplaceClip,
+        IntersectClip,
+        UniteClip
+    };
+
+
+    enum ItemSelectionMode {
+        ContainsItemShape = 0x0,
+        IntersectsItemShape = 0x1,
+        ContainsItemBoundingRect = 0x2,
+        IntersectsItemBoundingRect = 0x3
+    };
+
+    enum TransformationMode {
+        FastTransformation,
+        SmoothTransformation
+    };
+
+    enum Axis {
+        XAxis,
+        YAxis,
+        ZAxis
+    };
+
+    enum FocusReason {
+        MouseFocusReason,
+        TabFocusReason,
+        BacktabFocusReason,
+        ActiveWindowFocusReason,
+        PopupFocusReason,
+        ShortcutFocusReason,
+        MenuBarFocusReason,
+        OtherFocusReason,
+        NoFocusReason
+    };
+
+    enum ContextMenuPolicy {
+        NoContextMenu,
+        DefaultContextMenu,
+        ActionsContextMenu,
+        CustomContextMenu,
+        PreventContextMenu
+    };
+
+    enum InputMethodQuery {
+        ImMicroFocus,
+        ImFont,
+        ImCursorPosition,
+        ImSurroundingText,
+        ImCurrentSelection,
+        ImMaximumTextLength,
+        ImAnchorPosition
+    };
+
+    enum InputMethodHint {
+        ImhNone = 0x0,
+        ImhHiddenText = 0x1,
+        ImhNoAutoUppercase = 0x2,
+        ImhPreferNumbers = 0x4,
+        ImhPreferUppercase = 0x8,
+        ImhPreferLowercase = 0x10,
+        ImhNoPredictiveText = 0x20,
+
+        ImhDigitsOnly = 0x10000,
+        ImhFormattedNumbersOnly = 0x20000,
+        ImhUppercaseOnly = 0x40000,
+        ImhLowercaseOnly = 0x80000,
+        ImhDialableCharactersOnly = 0x100000,
+        ImhEmailCharactersOnly = 0x200000,
+        ImhUrlCharactersOnly = 0x400000,
+
+        ImhExclusiveInputMask = 0xffff0000
+    };
+    typedef QFlags<InputMethodHint> InputMethodHints;
+
+    enum ToolButtonStyle {
+        ToolButtonIconOnly,
+        ToolButtonTextOnly,
+        ToolButtonTextBesideIcon,
+        ToolButtonTextUnderIcon,
+        ToolButtonFollowStyle
+    };
+
+    enum LayoutDirection {
+        LeftToRight,
+        RightToLeft
+    };
+
+    enum AnchorPoint {
+        AnchorLeft = 0,
+        AnchorHorizontalCenter,
+        AnchorRight,
+        AnchorTop,
+        AnchorVerticalCenter,
+        AnchorBottom
+    };
+
+
+
+    enum DropAction {
+        CopyAction = 0x1,
+        MoveAction = 0x2,
+        LinkAction = 0x4,
+        ActionMask = 0xff,
+        TargetMoveAction = 0x8002,
+        IgnoreAction = 0x0
+    };
+    typedef QFlags<DropAction> DropActions;
+
+    enum CheckState {
+        Unchecked,
+        PartiallyChecked,
+        Checked
+    };
+
+    enum ItemDataRole {
+        DisplayRole = 0,
+        DecorationRole = 1,
+        EditRole = 2,
+        ToolTipRole = 3,
+        StatusTipRole = 4,
+        WhatsThisRole = 5,
+
+        FontRole = 6,
+        TextAlignmentRole = 7,
+        BackgroundColorRole = 8,
+        BackgroundRole = 8,
+        TextColorRole = 9,
+        ForegroundRole = 9,
+        CheckStateRole = 10,
+
+        AccessibleTextRole = 11,
+        AccessibleDescriptionRole = 12,
+
+        SizeHintRole = 13,
+
+        DisplayPropertyRole = 27,
+        DecorationPropertyRole = 28,
+        ToolTipPropertyRole = 29,
+        StatusTipPropertyRole = 30,
+        WhatsThisPropertyRole = 31,
+
+        UserRole = 32
+    };
+
+    enum ItemFlag {
+        NoItemFlags = 0,
+        ItemIsSelectable = 1,
+        ItemIsEditable = 2,
+        ItemIsDragEnabled = 4,
+        ItemIsDropEnabled = 8,
+        ItemIsUserCheckable = 16,
+        ItemIsEnabled = 32,
+        ItemIsTristate = 64
+    };
+    typedef QFlags<ItemFlag> ItemFlags;
+
+    enum MatchFlag {
+        MatchExactly = 0,
+        MatchContains = 1,
+        MatchStartsWith = 2,
+        MatchEndsWith = 3,
+        MatchRegExp = 4,
+        MatchWildcard = 5,
+        MatchFixedString = 8,
+        MatchCaseSensitive = 16,
+        MatchWrap = 32,
+        MatchRecursive = 64
+    };
+    typedef QFlags<MatchFlag> MatchFlags;
+
+
+
+
+
+
+    typedef unsigned long HANDLE;
+
+
+
+
+
+    typedef WindowFlags WFlags;
+
+    enum WindowModality {
+        NonModal,
+        WindowModal,
+        ApplicationModal
+    };
+
+    enum TextInteractionFlag {
+        NoTextInteraction = 0,
+        TextSelectableByMouse = 1,
+        TextSelectableByKeyboard = 2,
+        LinksAccessibleByMouse = 4,
+        LinksAccessibleByKeyboard = 8,
+        TextEditable = 16,
+
+        TextEditorInteraction = TextSelectableByMouse | TextSelectableByKeyboard | TextEditable,
+        TextBrowserInteraction = TextSelectableByMouse | LinksAccessibleByMouse | LinksAccessibleByKeyboard
+    };
+    typedef QFlags<TextInteractionFlag> TextInteractionFlags;
+
+    enum EventPriority {
+        HighEventPriority = 1,
+        NormalEventPriority = 0,
+        LowEventPriority = -1
+    };
+
+    enum SizeHint {
+        MinimumSize,
+        PreferredSize,
+        MaximumSize,
+        MinimumDescent,
+        NSizeHints
+    };
+
+    enum WindowFrameSection {
+        NoSection,
+        LeftSection,
+        TopLeftSection,
+        TopSection,
+        TopRightSection,
+        RightSection,
+        BottomRightSection,
+        BottomSection,
+        BottomLeftSection,
+        TitleBarArea
+    };
+
+    enum Initialization {
+        Uninitialized
+    };
+
+    enum CoordinateSystem {
+        DeviceCoordinates,
+        LogicalCoordinates
+    };
+
+    enum TouchPointState {
+        TouchPointPressed = 0x01,
+        TouchPointMoved = 0x02,
+        TouchPointStationary = 0x04,
+        TouchPointReleased = 0x08,
+        TouchPointStateMask = 0x0f,
+
+        TouchPointPrimary = 0x10
+    };
+    typedef QFlags<TouchPointState> TouchPointStates;
+
+    enum GestureState
+    {
+        NoGesture,
+        GestureStarted = 1,
+        GestureUpdated = 2,
+        GestureFinished = 3,
+        GestureCanceled = 4
+    };
+
+    enum GestureType
+    {
+        TapGesture = 1,
+        TapAndHoldGesture = 2,
+        PanGesture = 3,
+        PinchGesture = 4,
+        SwipeGesture = 5,
+
+        CustomGesture = 0x0100,
+
+        LastGestureType = ~0u
+    };
+
+    enum GestureFlag
+    {
+        DontStartGestureOnChildren = 0x01,
+        ReceivePartialGestures = 0x02
+    };
+    typedef QFlags<GestureFlag> GestureFlags;
+
+    enum NavigationMode
+    {
+        NavigationModeNone,
+        NavigationModeKeypadTabOrder,
+        NavigationModeKeypadDirectional,
+        NavigationModeCursorAuto,
+        NavigationModeCursorForceVisible
+    };
+}
+
+
+
+
+inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, Qt::MouseButtons::enum_type f2) { return QFlags<Qt::MouseButtons::enum_type>(f1) | f2; } inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, QFlags<Qt::MouseButtons::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MouseButtons::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, Qt::Orientations::enum_type f2) { return QFlags<Qt::Orientations::enum_type>(f1) | f2; } inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, QFlags<Qt::Orientations::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Orientations::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, Qt::KeyboardModifiers::enum_type f2) { return QFlags<Qt::KeyboardModifiers::enum_type>(f1) | f2; } inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, QFlags<Qt::KeyboardModifiers::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::KeyboardModifiers::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, Qt::WindowFlags::enum_type f2) { return QFlags<Qt::WindowFlags::enum_type>(f1) | f2; } inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, QFlags<Qt::WindowFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, Qt::Alignment::enum_type f2) { return QFlags<Qt::Alignment::enum_type>(f1) | f2; } inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, QFlags<Qt::Alignment::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Alignment::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, Qt::ImageConversionFlags::enum_type f2) { return QFlags<Qt::ImageConversionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, QFlags<Qt::ImageConversionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ImageConversionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, Qt::DockWidgetAreas::enum_type f2) { return QFlags<Qt::DockWidgetAreas::enum_type>(f1) | f2; } inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, QFlags<Qt::DockWidgetAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DockWidgetAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, Qt::ToolBarAreas::enum_type f2) { return QFlags<Qt::ToolBarAreas::enum_type>(f1) | f2; } inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, QFlags<Qt::ToolBarAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ToolBarAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, Qt::WindowStates::enum_type f2) { return QFlags<Qt::WindowStates::enum_type>(f1) | f2; } inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, QFlags<Qt::WindowStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, Qt::DropActions::enum_type f2) { return QFlags<Qt::DropActions::enum_type>(f1) | f2; } inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, QFlags<Qt::DropActions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DropActions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, Qt::ItemFlags::enum_type f2) { return QFlags<Qt::ItemFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, QFlags<Qt::ItemFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ItemFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, Qt::MatchFlags::enum_type f2) { return QFlags<Qt::MatchFlags::enum_type>(f1) | f2; } inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, QFlags<Qt::MatchFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MatchFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, Qt::TextInteractionFlags::enum_type f2) { return QFlags<Qt::TextInteractionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, QFlags<Qt::TextInteractionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TextInteractionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, Qt::InputMethodHints::enum_type f2) { return QFlags<Qt::InputMethodHints::enum_type>(f1) | f2; } inline QFlags<Qt::InputMethodHints::enum_type> operator|(Qt::InputMethodHints::enum_type f1, QFlags<Qt::InputMethodHints::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::InputMethodHints::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, Qt::TouchPointStates::enum_type f2) { return QFlags<Qt::TouchPointStates::enum_type>(f1) | f2; } inline QFlags<Qt::TouchPointStates::enum_type> operator|(Qt::TouchPointStates::enum_type f1, QFlags<Qt::TouchPointStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TouchPointStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, Qt::GestureFlags::enum_type f2) { return QFlags<Qt::GestureFlags::enum_type>(f1) | f2; } inline QFlags<Qt::GestureFlags::enum_type> operator|(Qt::GestureFlags::enum_type f1, QFlags<Qt::GestureFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::GestureFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+
+typedef bool (*qInternalCallback)(void **);
+
+class QInternal {
+public:
+    enum PaintDeviceFlags {
+        UnknownDevice = 0x00,
+        Widget = 0x01,
+        Pixmap = 0x02,
+        Image = 0x03,
+        Printer = 0x04,
+        Picture = 0x05,
+        Pbuffer = 0x06,
+        FramebufferObject = 0x07,
+        CustomRaster = 0x08,
+        MacQuartz = 0x09,
+        PaintBuffer = 0x0a,
+        OpenGL = 0x0b
+    };
+    enum RelayoutType {
+        RelayoutNormal,
+        RelayoutDragging,
+        RelayoutDropped
+    };
+
+
+    enum Callback {
+        ConnectCallback,
+        DisconnectCallback,
+        AdoptCurrentThread,
+        EventNotifyCallback,
+        LastCallback
+    };
+
+    enum InternalFunction {
+        CreateThreadForAdoption,
+        RefAdoptedThread,
+        DerefAdoptedThread,
+        SetCurrentThreadToMainThread,
+        SetQObjectSender,
+        GetQObjectSender,
+        ResetQObjectSender,
+        LastInternalFunction
+    };
+
+    enum DockPosition {
+        LeftDock,
+        RightDock,
+        TopDock,
+        BottomDock,
+        DockCount
+    };
+
+    static bool registerCallback(Callback, qInternalCallback);
+    static bool unregisterCallback(Callback, qInternalCallback);
+
+    static bool activateCallbacks(Callback, void **);
+    static bool callFunction(InternalFunction func, void **);
+};
+# 1826 "/usr/include/qt4/QtCore/qnamespace.h"
+
+
+
+# 47 "/usr/include/qt4/QtCore/qbytearray.h" 2
+
+# 1 "/usr/include/string.h" 1 3 4
+# 26 "/usr/include/string.h" 3 4
+# 1 "/usr/include/features.h" 1 3 4
+# 347 "/usr/include/features.h" 3 4
+# 1 "/usr/include/sys/cdefs.h" 1 3 4
+# 353 "/usr/include/sys/cdefs.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 354 "/usr/include/sys/cdefs.h" 2 3 4
+# 348 "/usr/include/features.h" 2 3 4
+# 371 "/usr/include/features.h" 3 4
+# 1 "/usr/include/gnu/stubs.h" 1 3 4
+
+
+
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 5 "/usr/include/gnu/stubs.h" 2 3 4
+
+
+
+
+# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
+# 10 "/usr/include/gnu/stubs.h" 2 3 4
+# 372 "/usr/include/features.h" 2 3 4
+# 27 "/usr/include/string.h" 2 3 4
+
+extern "C" {
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 34 "/usr/include/string.h" 2 3 4
+
+
+
+
+
+
+
+
+
+extern void *memcpy (void *__restrict __dest,
+       __const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void *memmove (void *__dest, __const void *__src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
+        int __c, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern "C++"
+{
+extern void *memchr (void *__s, int __c, size_t __n)
+      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const void *memchr (__const void *__s, int __c, size_t __n)
+      throw () __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+memchr (void *__s, int __c, size_t __n) throw ()
+{
+  return __builtin_memchr (__s, __c, __n);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const void *
+memchr (__const void *__s, int __c, size_t __n) throw ()
+{
+  return __builtin_memchr (__s, __c, __n);
+}
+
+}
+
+
+
+
+
+
+
+
+
+
+extern "C++" void *rawmemchr (void *__s, int __c)
+     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" __const void *rawmemchr (__const void *__s, int __c)
+     throw () __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern "C++" void *memrchr (void *__s, int __c, size_t __n)
+      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" __const void *memrchr (__const void *__s, int __c, size_t __n)
+      throw () __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+
+
+extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncpy (char *__restrict __dest,
+        __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
+        size_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcmp (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strcoll (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+extern size_t strxfrm (char *__restrict __dest,
+         __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+# 1 "/usr/include/xlocale.h" 1 3 4
+# 28 "/usr/include/xlocale.h" 3 4
+typedef struct __locale_struct
+{
+
+  struct locale_data *__locales[13];
+
+
+  const unsigned short int *__ctype_b;
+  const int *__ctype_tolower;
+  const int *__ctype_toupper;
+
+
+  const char *__names[13];
+} *__locale_t;
+
+
+typedef __locale_t locale_t;
+# 162 "/usr/include/string.h" 2 3 4
+
+
+extern int strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+extern size_t strxfrm_l (char *__dest, __const char *__src, size_t __n,
+    __locale_t __l) throw () __attribute__ ((__nonnull__ (2, 4)));
+
+
+
+
+extern char *strdup (__const char *__s)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern char *strndup (__const char *__string, size_t __n)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
+# 208 "/usr/include/string.h" 3 4
+
+
+
+extern "C++"
+{
+extern char *strchr (char *__s, int __c)
+     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *strchr (__const char *__s, int __c)
+     throw () __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strchr (char *__s, int __c) throw ()
+{
+  return __builtin_strchr (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strchr (__const char *__s, int __c) throw ()
+{
+  return __builtin_strchr (__s, __c);
+}
+
+}
+
+
+
+
+
+
+extern "C++"
+{
+extern char *strrchr (char *__s, int __c)
+     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *strrchr (__const char *__s, int __c)
+     throw () __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strrchr (char *__s, int __c) throw ()
+{
+  return __builtin_strrchr (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strrchr (__const char *__s, int __c) throw ()
+{
+  return __builtin_strrchr (__s, __c);
+}
+
+}
+
+
+
+
+
+
+
+
+
+
+extern "C++" char *strchrnul (char *__s, int __c)
+     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern "C++" __const char *strchrnul (__const char *__s, int __c)
+     throw () __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+
+
+extern size_t strcspn (__const char *__s, __const char *__reject)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern size_t strspn (__const char *__s, __const char *__accept)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern "C++"
+{
+extern char *strpbrk (char *__s, __const char *__accept)
+     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern __const char *strpbrk (__const char *__s, __const char *__accept)
+     throw () __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strpbrk (char *__s, __const char *__accept) throw ()
+{
+  return __builtin_strpbrk (__s, __accept);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strpbrk (__const char *__s, __const char *__accept) throw ()
+{
+  return __builtin_strpbrk (__s, __accept);
+}
+
+}
+
+
+
+
+
+
+extern "C++"
+{
+extern char *strstr (char *__haystack, __const char *__needle)
+     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern __const char *strstr (__const char *__haystack,
+        __const char *__needle)
+     throw () __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strstr (char *__haystack, __const char *__needle) throw ()
+{
+  return __builtin_strstr (__haystack, __needle);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+strstr (__const char *__haystack, __const char *__needle) throw ()
+{
+  return __builtin_strstr (__haystack, __needle);
+}
+
+}
+
+
+
+
+
+
+
+extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern char *__strtok_r (char *__restrict __s,
+    __const char *__restrict __delim,
+    char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
+         char **__restrict __save_ptr)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+
+
+
+extern "C++" char *strcasestr (char *__haystack, __const char *__needle)
+     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+extern "C++" __const char *strcasestr (__const char *__haystack,
+           __const char *__needle)
+     throw () __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+# 380 "/usr/include/string.h" 3 4
+extern void *memmem (__const void *__haystack, size_t __haystacklen,
+       __const void *__needle, size_t __needlelen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern void *__mempcpy (void *__restrict __dest,
+   __const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern void *mempcpy (void *__restrict __dest,
+        __const void *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern size_t strlen (__const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern size_t strnlen (__const char *__string, size_t __maxlen)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern char *strerror (int __errnum) throw ();
+
+# 436 "/usr/include/string.h" 3 4
+extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern char *strerror_l (int __errnum, __locale_t __l) throw ();
+
+
+
+
+
+extern void __bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern void bcopy (__const void *__src, void *__dest, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern "C++"
+{
+extern char *index (char *__s, int __c)
+     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *index (__const char *__s, int __c)
+     throw () __asm ("index") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+index (char *__s, int __c) throw ()
+{
+  return __builtin_index (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+index (__const char *__s, int __c) throw ()
+{
+  return __builtin_index (__s, __c);
+}
+
+}
+
+
+
+
+
+
+
+extern "C++"
+{
+extern char *rindex (char *__s, int __c)
+     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+extern __const char *rindex (__const char *__s, int __c)
+     throw () __asm ("rindex") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+rindex (char *__s, int __c) throw ()
+{
+  return __builtin_rindex (__s, __c);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __const char *
+rindex (__const char *__s, int __c) throw ()
+{
+  return __builtin_rindex (__s, __c);
+}
+
+}
+
+
+
+
+
+
+
+extern int ffs (int __i) throw () __attribute__ ((__const__));
+
+
+
+
+extern int ffsl (long int __l) throw () __attribute__ ((__const__));
+
+__extension__ extern int ffsll (long long int __ll)
+     throw () __attribute__ ((__const__));
+
+
+
+
+extern int strcasecmp (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int strcasecmp_l (__const char *__s1, __const char *__s2,
+    __locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+extern int strncasecmp_l (__const char *__s1, __const char *__s2,
+     size_t __n, __locale_t __loc)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));
+
+
+
+
+
+extern char *strsep (char **__restrict __stringp,
+       __const char *__restrict __delim)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern char *strsignal (int __sig) throw ();
+
+
+extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern char *__stpncpy (char *__restrict __dest,
+   __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern char *stpncpy (char *__restrict __dest,
+        __const char *__restrict __src, size_t __n)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int strverscmp (__const char *__s1, __const char *__s2)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern char *strfry (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern void *memfrob (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern "C++" char *basename (char *__filename)
+     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
+extern "C++" __const char *basename (__const char *__filename)
+     throw () __asm ("basename") __attribute__ ((__nonnull__ (1)));
+# 640 "/usr/include/string.h" 3 4
+# 1 "/usr/include/bits/string3.h" 1 3 4
+# 23 "/usr/include/bits/string3.h" 3 4
+extern void __warn_memset_zero_len (void) __attribute__((__warning__ ("memset used with constant zero length parameter; this could be due to transposed parameters")))
+                                                                                                   ;
+# 48 "/usr/include/bits/string3.h" 3 4
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+memcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()
+
+{
+  return __builtin___memcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+memmove (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()
+
+{
+  return __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+mempcpy (void *__restrict __dest, __const void *__restrict __src, size_t __len) throw ()
+
+{
+  return __builtin___mempcpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+# 77 "/usr/include/bits/string3.h" 3 4
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void *
+memset (void *__dest, int __ch, size_t __len) throw ()
+{
+  if (__builtin_constant_p (__len) && __len == 0
+      && (!__builtin_constant_p (__ch) || __ch != 0))
+    {
+      __warn_memset_zero_len ();
+      return __dest;
+    }
+  return __builtin___memset_chk (__dest, __ch, __len, __builtin_object_size (__dest, 0));
+}
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
+bcopy (__const void *__restrict __src, void *__restrict __dest, size_t __len) throw ()
+
+{
+  (void) __builtin___memmove_chk (__dest, __src, __len, __builtin_object_size (__dest, 0));
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) void
+bzero (void *__dest, size_t __len) throw ()
+{
+  (void) __builtin___memset_chk (__dest, '\0', __len, __builtin_object_size (__dest, 0));
+}
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strcpy (char *__restrict __dest, __const char *__restrict __src) throw ()
+{
+  return __builtin___strcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
+}
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+stpcpy (char *__restrict __dest, __const char *__restrict __src) throw ()
+{
+  return __builtin___stpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
+}
+
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strncpy (char *__restrict __dest, __const char *__restrict __src, size_t __len) throw ()
+
+{
+  return __builtin___strncpy_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
+}
+
+
+extern char *__stpncpy_chk (char *__dest, __const char *__src, size_t __n,
+       size_t __destlen) throw ();
+extern char *__stpncpy_alias (char *__dest, __const char *__src, size_t __n) throw () __asm__ ("" "stpncpy")
+
+                                 ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+stpncpy (char *__dest, __const char *__src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
+      && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
+    return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
+  return __stpncpy_alias (__dest, __src, __n);
+}
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strcat (char *__restrict __dest, __const char *__restrict __src) throw ()
+{
+  return __builtin___strcat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1));
+}
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) char *
+strncat (char *__restrict __dest, __const char *__restrict __src, size_t __len) throw ()
+
+{
+  return __builtin___strncat_chk (__dest, __src, __len, __builtin_object_size (__dest, 2 > 1));
+}
+# 641 "/usr/include/string.h" 2 3 4
+
+
+
+}
+# 49 "/usr/include/qt4/QtCore/qbytearray.h" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdarg.h" 1 3 4
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdarg.h" 3 4
+typedef __builtin_va_list __gnuc_va_list;
+# 102 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdarg.h" 3 4
+typedef __gnuc_va_list va_list;
+# 50 "/usr/include/qt4/QtCore/qbytearray.h" 2
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+
+
+
+
+ char *qstrdup(const char *);
+
+inline uint qstrlen(const char *str)
+{ return str ? uint(strlen(str)) : 0; }
+
+inline uint qstrnlen(const char *str, uint maxlen)
+{
+    uint length = 0;
+    if (str) {
+        while (length < maxlen && *str++)
+            length++;
+    }
+    return length;
+}
+
+ char *qstrcpy(char *dst, const char *src);
+ char *qstrncpy(char *dst, const char *src, uint len);
+
+ int qstrcmp(const char *str1, const char *str2);
+ int qstrcmp(const QByteArray &str1, const QByteArray &str2);
+ int qstrcmp(const QByteArray &str1, const char *str2);
+static inline int qstrcmp(const char *str1, const QByteArray &str2)
+{ return -qstrcmp(str2, str1); }
+
+inline int qstrncmp(const char *str1, const char *str2, uint len)
+{
+    return (str1 && str2) ? strncmp(str1, str2, len)
+        : (str1 ? 1 : (str2 ? -1 : 0));
+}
+ int qstricmp(const char *, const char *);
+ int qstrnicmp(const char *, const char *, uint len);
+
+
+ int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap);
+ int qsnprintf(char *str, size_t n, const char *fmt, ...);
+# 116 "/usr/include/qt4/QtCore/qbytearray.h"
+ quint16 qChecksum(const char *s, uint len);
+
+class QByteRef;
+class QString;
+class QDataStream;
+template <typename T> class QList;
+
+class QByteArray
+{
+private:
+    struct Data {
+        QBasicAtomicInt ref;
+        int alloc, size;
+
+
+
+        char *data;
+        char array[1];
+    };
+
+public:
+    inline QByteArray();
+    QByteArray(const char *);
+    QByteArray(const char *, int size);
+    QByteArray(int size, char c);
+    QByteArray(int size, Qt::Initialization);
+    inline QByteArray(const QByteArray &);
+    inline ~QByteArray();
+
+    QByteArray &operator=(const QByteArray &);
+    QByteArray &operator=(const char *str);
+
+    inline int size() const;
+    bool isEmpty() const;
+    void resize(int size);
+
+    QByteArray &fill(char c, int size = -1);
+
+    int capacity() const;
+    void reserve(int size);
+    void squeeze();
+
+
+    operator const char *() const;
+    operator const void *() const;
+
+    char *data();
+    const char *data() const;
+    inline const char *constData() const;
+    inline void detach();
+    bool isDetached() const;
+    void clear();
+
+
+
+
+
+
+    char at(int i) const;
+    char operator[](int i) const;
+    char operator[](uint i) const;
+
+    QByteRef operator[](int i);
+    QByteRef operator[](uint i);
+
+    int indexOf(char c, int from = 0) const;
+    int indexOf(const char *c, int from = 0) const;
+    int indexOf(const QByteArray &a, int from = 0) const;
+    int lastIndexOf(char c, int from = -1) const;
+    int lastIndexOf(const char *c, int from = -1) const;
+    int lastIndexOf(const QByteArray &a, int from = -1) const;
+
+    QBool contains(char c) const;
+    QBool contains(const char *a) const;
+    QBool contains(const QByteArray &a) const;
+    int count(char c) const;
+    int count(const char *a) const;
+    int count(const QByteArray &a) const;
+
+    QByteArray left(int len) const;
+    QByteArray right(int len) const;
+    QByteArray mid(int index, int len = -1) const;
+
+    bool startsWith(const QByteArray &a) const;
+    bool startsWith(char c) const;
+    bool startsWith(const char *c) const;
+
+    bool endsWith(const QByteArray &a) const;
+    bool endsWith(char c) const;
+    bool endsWith(const char *c) const;
+
+    void truncate(int pos);
+    void chop(int n);
+
+    QByteArray toLower() const;
+    QByteArray toUpper() const;
+
+    QByteArray trimmed() const;
+    QByteArray simplified() const;
+    QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const;
+    QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const;
+# 225 "/usr/include/qt4/QtCore/qbytearray.h"
+    QByteArray &prepend(char c);
+    QByteArray &prepend(const char *s);
+    QByteArray &prepend(const char *s, int len);
+    QByteArray &prepend(const QByteArray &a);
+    QByteArray &append(char c);
+    QByteArray &append(const char *s);
+    QByteArray &append(const char *s, int len);
+    QByteArray &append(const QByteArray &a);
+    QByteArray &insert(int i, char c);
+    QByteArray &insert(int i, const char *s);
+    QByteArray &insert(int i, const char *s, int len);
+    QByteArray &insert(int i, const QByteArray &a);
+    QByteArray &remove(int index, int len);
+    QByteArray &replace(int index, int len, const char *s);
+    QByteArray &replace(int index, int len, const QByteArray &s);
+    QByteArray &replace(char before, const char *after);
+    QByteArray &replace(char before, const QByteArray &after);
+    QByteArray &replace(const char *before, const char *after);
+    QByteArray &replace(const char *before, int bsize, const char *after, int asize);
+    QByteArray &replace(const QByteArray &before, const QByteArray &after);
+    QByteArray &replace(const QByteArray &before, const char *after);
+    QByteArray &replace(const char *before, const QByteArray &after);
+    QByteArray &replace(char before, char after);
+    QByteArray &operator+=(char c);
+    QByteArray &operator+=(const char *s);
+    QByteArray &operator+=(const QByteArray &a);
+
+    QList<QByteArray> split(char sep) const;
+
+    QByteArray repeated(int times) const;
+
+
+    QByteArray &append(const QString &s);
+    QByteArray &insert(int i, const QString &s);
+    QByteArray &replace(const QString &before, const char *after);
+    QByteArray &replace(char c, const QString &after);
+    QByteArray &replace(const QString &before, const QByteArray &after);
+
+    QByteArray &operator+=(const QString &s);
+    int indexOf(const QString &s, int from = 0) const;
+    int lastIndexOf(const QString &s, int from = -1) const;
+
+
+    inline bool operator==(const QString &s2) const;
+    inline bool operator!=(const QString &s2) const;
+    inline bool operator<(const QString &s2) const;
+    inline bool operator>(const QString &s2) const;
+    inline bool operator<=(const QString &s2) const;
+    inline bool operator>=(const QString &s2) const;
+
+
+    short toShort(bool *ok = 0, int base = 10) const;
+    ushort toUShort(bool *ok = 0, int base = 10) const;
+    int toInt(bool *ok = 0, int base = 10) const;
+    uint toUInt(bool *ok = 0, int base = 10) const;
+    long toLong(bool *ok = 0, int base = 10) const;
+    ulong toULong(bool *ok = 0, int base = 10) const;
+    qlonglong toLongLong(bool *ok = 0, int base = 10) const;
+    qulonglong toULongLong(bool *ok = 0, int base = 10) const;
+    float toFloat(bool *ok = 0) const;
+    double toDouble(bool *ok = 0) const;
+    QByteArray toBase64() const;
+    QByteArray toHex() const;
+    QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(),
+                                 const QByteArray &include = QByteArray(),
+                                 char percent = '%') const;
+
+    QByteArray &setNum(short, int base = 10);
+    QByteArray &setNum(ushort, int base = 10);
+    QByteArray &setNum(int, int base = 10);
+    QByteArray &setNum(uint, int base = 10);
+    QByteArray &setNum(qlonglong, int base = 10);
+    QByteArray &setNum(qulonglong, int base = 10);
+    QByteArray &setNum(float, char f = 'g', int prec = 6);
+    QByteArray &setNum(double, char f = 'g', int prec = 6);
+
+    static QByteArray number(int, int base = 10);
+    static QByteArray number(uint, int base = 10);
+    static QByteArray number(qlonglong, int base = 10);
+    static QByteArray number(qulonglong, int base = 10);
+    static QByteArray number(double, char f = 'g', int prec = 6);
+    static QByteArray fromRawData(const char *, int size);
+    static QByteArray fromBase64(const QByteArray &base64);
+    static QByteArray fromHex(const QByteArray &hexEncoded);
+    static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%');
+
+
+    typedef char *iterator;
+    typedef const char *const_iterator;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    iterator begin();
+    const_iterator begin() const;
+    const_iterator constBegin() const;
+    iterator end();
+    const_iterator end() const;
+    const_iterator constEnd() const;
+
+
+    typedef const char & const_reference;
+    typedef char & reference;
+    typedef char value_type;
+    void push_back(char c);
+    void push_back(const char *c);
+    void push_back(const QByteArray &a);
+    void push_front(char c);
+    void push_front(const char *c);
+    void push_front(const QByteArray &a);
+
+    inline int count() const { return d->size; }
+    int length() const { return d->size; }
+    bool isNull() const;
+# 363 "/usr/include/qt4/QtCore/qbytearray.h"
+private:
+    operator QNoImplicitBoolCast() const;
+    static Data shared_null;
+    static Data shared_empty;
+    Data *d;
+    QByteArray(Data *dd, int , int ) : d(dd) {}
+    void realloc(int alloc);
+    void expand(int i);
+    QByteArray nulTerminated() const;
+
+    friend class QByteRef;
+    friend class QString;
+    friend QByteArray qUncompress(const uchar *data, int nbytes);
+public:
+    typedef Data * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+inline QByteArray::QByteArray(): d(&shared_null) { d->ref.ref(); }
+inline QByteArray::~QByteArray() { if (!d->ref.deref()) qFree(d); }
+inline int QByteArray::size() const
+{ return d->size; }
+# 394 "/usr/include/qt4/QtCore/qbytearray.h"
+inline char QByteArray::at(int i) const
+{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qbytearray.h",395) : qt_noop()); return d->data[i]; }
+inline char QByteArray::operator[](int i) const
+{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qbytearray.h",397) : qt_noop()); return d->data[i]; }
+inline char QByteArray::operator[](uint i) const
+{ ((!(i < uint(size()))) ? qt_assert("i < uint(size())","/usr/include/qt4/QtCore/qbytearray.h",399) : qt_noop()); return d->data[i]; }
+
+
+inline bool QByteArray::isEmpty() const
+{ return d->size == 0; }
+
+inline QByteArray::operator const char *() const
+{ return d->data; }
+inline QByteArray::operator const void *() const
+{ return d->data; }
+
+inline char *QByteArray::data()
+{ detach(); return d->data; }
+inline const char *QByteArray::data() const
+{ return d->data; }
+inline const char *QByteArray::constData() const
+{ return d->data; }
+inline void QByteArray::detach()
+{ if (d->ref != 1 || d->data != d->array) realloc(d->size); }
+inline bool QByteArray::isDetached() const
+{ return d->ref == 1; }
+inline QByteArray::QByteArray(const QByteArray &a) : d(a.d)
+{ d->ref.ref(); }
+
+
+
+
+
+inline int QByteArray::capacity() const
+{ return d->alloc; }
+
+inline void QByteArray::reserve(int asize)
+{ if (d->ref != 1 || asize > d->alloc) realloc(asize); }
+
+inline void QByteArray::squeeze()
+{ if (d->size < d->alloc) realloc(d->size); }
+
+class QByteRef {
+    QByteArray &a;
+    int i;
+    inline QByteRef(QByteArray &array, int idx)
+        : a(array),i(idx) {}
+    friend class QByteArray;
+public:
+
+
+
+
+    inline operator char() const
+        { return i < a.d->size ? a.d->data[i] : char(0); }
+
+    inline QByteRef &operator=(char c)
+        { if (i >= a.d->size) a.expand(i); else a.detach();
+          a.d->data[i] = c; return *this; }
+    inline QByteRef &operator=(const QByteRef &c)
+        { if (i >= a.d->size) a.expand(i); else a.detach();
+          a.d->data[i] = c.a.d->data[c.i]; return *this; }
+    inline bool operator==(char c) const
+    { return a.d->data[i] == c; }
+    inline bool operator!=(char c) const
+    { return a.d->data[i] != c; }
+    inline bool operator>(char c) const
+    { return a.d->data[i] > c; }
+    inline bool operator>=(char c) const
+    { return a.d->data[i] >= c; }
+    inline bool operator<(char c) const
+    { return a.d->data[i] < c; }
+    inline bool operator<=(char c) const
+    { return a.d->data[i] <= c; }
+};
+
+inline QByteRef QByteArray::operator[](int i)
+{ ((!(i >= 0)) ? qt_assert("i >= 0","/usr/include/qt4/QtCore/qbytearray.h",471) : qt_noop()); return QByteRef(*this, i); }
+inline QByteRef QByteArray::operator[](uint i)
+{ return QByteRef(*this, i); }
+inline QByteArray::iterator QByteArray::begin()
+{ detach(); return d->data; }
+inline QByteArray::const_iterator QByteArray::begin() const
+{ return d->data; }
+inline QByteArray::const_iterator QByteArray::constBegin() const
+{ return d->data; }
+inline QByteArray::iterator QByteArray::end()
+{ detach(); return d->data + d->size; }
+inline QByteArray::const_iterator QByteArray::end() const
+{ return d->data + d->size; }
+inline QByteArray::const_iterator QByteArray::constEnd() const
+{ return d->data + d->size; }
+inline QByteArray &QByteArray::operator+=(char c)
+{ return append(c); }
+inline QByteArray &QByteArray::operator+=(const char *s)
+{ return append(s); }
+inline QByteArray &QByteArray::operator+=(const QByteArray &a)
+{ return append(a); }
+inline void QByteArray::push_back(char c)
+{ append(c); }
+inline void QByteArray::push_back(const char *c)
+{ append(c); }
+inline void QByteArray::push_back(const QByteArray &a)
+{ append(a); }
+inline void QByteArray::push_front(char c)
+{ prepend(c); }
+inline void QByteArray::push_front(const char *c)
+{ prepend(c); }
+inline void QByteArray::push_front(const QByteArray &a)
+{ prepend(a); }
+inline QBool QByteArray::contains(const QByteArray &a) const
+{ return QBool(indexOf(a) != -1); }
+inline QBool QByteArray::contains(char c) const
+{ return QBool(indexOf(c) != -1); }
+inline bool operator==(const QByteArray &a1, const QByteArray &a2)
+{ return (a1.size() == a2.size()) && (memcmp(a1.constData(), a2.constData(), a1.size())==0); }
+inline bool operator==(const QByteArray &a1, const char *a2)
+{ return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); }
+inline bool operator==(const char *a1, const QByteArray &a2)
+{ return a1 ? qstrcmp(a1,a2) == 0 : a2.isEmpty(); }
+inline bool operator!=(const QByteArray &a1, const QByteArray &a2)
+{ return !(a1==a2); }
+inline bool operator!=(const QByteArray &a1, const char *a2)
+{ return a2 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); }
+inline bool operator!=(const char *a1, const QByteArray &a2)
+{ return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); }
+inline bool operator<(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) < 0; }
+ inline bool operator<(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) < 0; }
+inline bool operator<(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) < 0; }
+inline bool operator<=(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) <= 0; }
+inline bool operator<=(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) <= 0; }
+inline bool operator<=(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) <= 0; }
+inline bool operator>(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) > 0; }
+inline bool operator>(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) > 0; }
+inline bool operator>(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) > 0; }
+inline bool operator>=(const QByteArray &a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) >= 0; }
+inline bool operator>=(const QByteArray &a1, const char *a2)
+{ return qstrcmp(a1, a2) >= 0; }
+inline bool operator>=(const char *a1, const QByteArray &a2)
+{ return qstrcmp(a1, a2) >= 0; }
+inline const QByteArray operator+(const QByteArray &a1, const QByteArray &a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(const QByteArray &a1, const char *a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(const QByteArray &a1, char a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(const char *a1, const QByteArray &a2)
+{ return QByteArray(a1) += a2; }
+inline const QByteArray operator+(char a1, const QByteArray &a2)
+{ return QByteArray(&a1, 1) += a2; }
+inline QBool QByteArray::contains(const char *c) const
+{ return QBool(indexOf(c) != -1); }
+inline QByteArray &QByteArray::replace(char before, const char *c)
+{ return replace(&before, 1, c, qstrlen(c)); }
+inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c)
+{ return replace(before.constData(), before.size(), c, qstrlen(c)); }
+inline QByteArray &QByteArray::replace(const char *before, const char *after)
+{ return replace(before, qstrlen(before), after, qstrlen(after)); }
+
+inline QByteArray &QByteArray::setNum(short n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QByteArray &QByteArray::setNum(ushort n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QByteArray &QByteArray::setNum(int n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QByteArray &QByteArray::setNum(uint n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QByteArray &QByteArray::setNum(float n, char f, int prec)
+{ return setNum(double(n),f,prec); }
+
+
+
+ QDataStream &operator<<(QDataStream &, const QByteArray &);
+ QDataStream &operator>>(QDataStream &, QByteArray &);
+
+
+
+ QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1);
+ QByteArray qUncompress(const uchar* data, int nbytes);
+inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1)
+{ return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); }
+inline QByteArray qUncompress(const QByteArray& data)
+{ return qUncompress(reinterpret_cast<const uchar*>(data.constData()), data.size()); }
+
+
+template <> class QTypeInfo<QByteArray > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QByteArray)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QByteArray"; } };
+template <> inline bool qIsDetached<QByteArray>(QByteArray &t) { return t.isDetached(); } template <> inline void qSwap<QByteArray>(QByteArray &value1, QByteArray &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+
+
+
+
+# 47 "/usr/include/qt4/QtCore/qstring.h" 2
+# 60 "/usr/include/qt4/QtCore/qstring.h"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 3
+       
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
+# 275 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
+# 276 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
+# 279 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 3
+       
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Alloc>
+    class allocator;
+
+  template<class _CharT>
+    struct char_traits;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+           typename _Alloc = allocator<_CharT> >
+    class basic_string;
+
+  template<> struct char_traits<char>;
+
+  typedef basic_string<char> string;
+
+
+  template<> struct char_traits<wchar_t>;
+
+  typedef basic_string<wchar_t> wstring;
+# 75 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stringfwd.h" 3
+}
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 1 3
+# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::ptrdiff_t;
+  using ::size_t;
+
+}
+# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/functexcept.h" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/functexcept.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception_defines.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/functexcept.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  void
+  __throw_bad_exception(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_alloc(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_cast(void) __attribute__((__noreturn__));
+
+  void
+  __throw_bad_typeid(void) __attribute__((__noreturn__));
+
+
+  void
+  __throw_logic_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_domain_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_invalid_argument(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_length_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_out_of_range(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_runtime_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_range_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_overflow_error(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_underflow_error(const char*) __attribute__((__noreturn__));
+
+
+  void
+  __throw_ios_failure(const char*) __attribute__((__noreturn__));
+
+  void
+  __throw_system_error(int) __attribute__((__noreturn__));
+
+  void
+  __throw_future_error(int) __attribute__((__noreturn__));
+
+
+  void
+  __throw_bad_function_call() __attribute__((__noreturn__));
+
+}
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 1 3
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
+       
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
+# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator;
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  struct __true_type { };
+  struct __false_type { };
+
+  template<bool>
+    struct __truth_type
+    { typedef __false_type __type; };
+
+  template<>
+    struct __truth_type<true>
+    { typedef __true_type __type; };
+
+
+
+  template<class _Sp, class _Tp>
+    struct __traitor
+    {
+      enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
+      typedef typename __truth_type<__value>::__type __type;
+    };
+
+
+  template<typename, typename>
+    struct __are_same
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Tp>
+    struct __are_same<_Tp, _Tp>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<typename _Tp>
+    struct __is_void
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_void<void>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_integer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+
+
+
+  template<>
+    struct __is_integer<bool>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<>
+    struct __is_integer<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
+  template<>
+    struct __is_integer<short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned short>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned int>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_integer<unsigned long long>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_floating
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+
+  template<>
+    struct __is_floating<float>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_floating<double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_floating<long double>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_pointer
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Tp>
+    struct __is_pointer<_Tp*>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_normal_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<typename _Iterator, typename _Container>
+    struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator,
+             _Container> >
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_arithmetic
+    : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct __is_fundamental
+    : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> >
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct __is_scalar
+    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
+    { };
+
+
+
+
+  template<typename _Tp>
+    struct __is_char
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_char<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<>
+    struct __is_char<wchar_t>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+  template<typename _Tp>
+    struct __is_byte
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+
+  template<>
+    struct __is_byte<char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_byte<signed char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+  template<>
+    struct __is_byte<unsigned char>
+    {
+      enum { __value = 1 };
+      typedef __true_type __type;
+    };
+
+
+
+
+  template<typename _Tp>
+    struct __is_move_iterator
+    {
+      enum { __value = 0 };
+      typedef __false_type __type;
+    };
+# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cpp_type_traits.h" 3
+}
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/type_traits.h" 1 3
+# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/type_traits.h" 3
+       
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/type_traits.h" 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+
+  template<bool, typename>
+    struct __enable_if
+    { };
+
+  template<typename _Tp>
+    struct __enable_if<true, _Tp>
+    { typedef _Tp __type; };
+
+
+
+  template<bool _Cond, typename _Iftrue, typename _Iffalse>
+    struct __conditional_type
+    { typedef _Iftrue __type; };
+
+  template<typename _Iftrue, typename _Iffalse>
+    struct __conditional_type<false, _Iftrue, _Iffalse>
+    { typedef _Iffalse __type; };
+
+
+
+  template<typename _Tp>
+    struct __add_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+
+    public:
+      typedef typename __if_type::__type __type;
+    };
+
+  template<>
+    struct __add_unsigned<char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __add_unsigned<signed char>
+    { typedef unsigned char __type; };
+
+  template<>
+    struct __add_unsigned<short>
+    { typedef unsigned short __type; };
+
+  template<>
+    struct __add_unsigned<int>
+    { typedef unsigned int __type; };
+
+  template<>
+    struct __add_unsigned<long>
+    { typedef unsigned long __type; };
+
+  template<>
+    struct __add_unsigned<long long>
+    { typedef unsigned long long __type; };
+
+
+  template<>
+    struct __add_unsigned<bool>;
+
+  template<>
+    struct __add_unsigned<wchar_t>;
+
+
+
+  template<typename _Tp>
+    struct __remove_unsigned
+    {
+    private:
+      typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+
+    public:
+      typedef typename __if_type::__type __type;
+    };
+
+  template<>
+    struct __remove_unsigned<char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned char>
+    { typedef signed char __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned short>
+    { typedef short __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned int>
+    { typedef int __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned long>
+    { typedef long __type; };
+
+  template<>
+    struct __remove_unsigned<unsigned long long>
+    { typedef long long __type; };
+
+
+  template<>
+    struct __remove_unsigned<bool>;
+
+  template<>
+    struct __remove_unsigned<wchar_t>;
+
+
+
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type* __ptr)
+    { return __ptr == 0; }
+
+  template<typename _Type>
+    inline bool
+    __is_null_pointer(_Type)
+    { return false; }
+
+
+
+  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+    struct __promote
+    { typedef double __type; };
+
+  template<typename _Tp>
+    struct __promote<_Tp, false>
+    { typedef _Tp __type; };
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2
+    {
+    private:
+      typedef typename __promote<_Tp>::__type __type1;
+      typedef typename __promote<_Up>::__type __type2;
+
+    public:
+      typedef __typeof__(__type1() + __type2()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp>
+    struct __promote_3
+    {
+    private:
+      typedef typename __promote<_Tp>::__type __type1;
+      typedef typename __promote<_Up>::__type __type2;
+      typedef typename __promote<_Vp>::__type __type3;
+
+    public:
+      typedef __typeof__(__type1() + __type2() + __type3()) __type;
+    };
+
+  template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
+    struct __promote_4
+    {
+    private:
+      typedef typename __promote<_Tp>::__type __type1;
+      typedef typename __promote<_Up>::__type __type2;
+      typedef typename __promote<_Vp>::__type __type3;
+      typedef typename __promote<_Wp>::__type __type4;
+
+    public:
+      typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type;
+    };
+
+}
+# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 1 3
+# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3
+       
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3
+  template<typename _Value>
+    struct __numeric_traits_integer
+    {
+
+      static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0);
+      static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0);
+
+
+
+      static const bool __is_signed = ((_Value)(-1) < 0);
+      static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0));
+    };
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__min;
+
+  template<typename _Value>
+    const _Value __numeric_traits_integer<_Value>::__max;
+
+  template<typename _Value>
+    const bool __numeric_traits_integer<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_integer<_Value>::__digits;
+# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/numeric_traits.h" 3
+  template<typename _Value>
+    struct __numeric_traits_floating
+    {
+
+      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 3010 / 10000);
+
+
+      static const bool __is_signed = true;
+      static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
+      static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
+    };
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_digits10;
+
+  template<typename _Value>
+    const bool __numeric_traits_floating<_Value>::__is_signed;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__digits10;
+
+  template<typename _Value>
+    const int __numeric_traits_floating<_Value>::__max_exponent10;
+
+  template<typename _Value>
+    struct __numeric_traits
+    : public __conditional_type<std::__is_integer<_Value>::__value,
+    __numeric_traits_integer<_Value>,
+    __numeric_traits_floating<_Value> >::__type
+    { };
+
+}
+# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/concept_check.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/concept_check.h" 3
+       
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/concept_check.h" 3
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 2 3
+# 95 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/move.h" 3
+  template<typename _Tp>
+    inline void
+    swap(_Tp& __a, _Tp& __b)
+    {
+
+     
+
+      _Tp __tmp = (__a);
+      __a = (__b);
+      __b = (__tmp);
+    }
+
+
+
+  template<typename _Tp, size_t _Nm>
+    inline void
+    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+    {
+      for (size_t __n = 0; __n < _Nm; ++__n)
+ swap(__a[__n], __b[__n]);
+    }
+
+}
+# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 2 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  template<class _T1, class _T2>
+    struct pair
+    {
+      typedef _T1 first_type;
+      typedef _T2 second_type;
+
+      _T1 first;
+      _T2 second;
+
+
+
+
+
+      pair()
+      : first(), second() { }
+
+
+      pair(const _T1& __a, const _T2& __b)
+      : first(__a), second(__b) { }
+# 117 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
+      template<class _U1, class _U2>
+        pair(const pair<_U1, _U2>& __p)
+ : first(__p.first),
+   second(__p.second) { }
+# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
+    };
+
+
+  template<class _T1, class _T2>
+    inline bool
+    operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first == __y.first && __x.second == __y.second; }
+
+
+  template<class _T1, class _T2>
+    inline bool
+    operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __x.first < __y.first
+      || (!(__y.first < __x.first) && __x.second < __y.second); }
+
+
+  template<class _T1, class _T2>
+    inline bool
+    operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x == __y); }
+
+
+  template<class _T1, class _T2>
+    inline bool
+    operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return __y < __x; }
+
+
+  template<class _T1, class _T2>
+    inline bool
+    operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__y < __x); }
+
+
+  template<class _T1, class _T2>
+    inline bool
+    operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
+    { return !(__x < __y); }
+# 215 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
+  template<class _T1, class _T2>
+    inline pair<_T1, _T2>
+    make_pair(_T1 __x, _T2 __y)
+    { return pair<_T1, _T2>(__x, __y); }
+# 261 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_pair.h" 3
+}
+# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
+       
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
+  struct input_iterator_tag { };
+
+
+  struct output_iterator_tag { };
+
+
+  struct forward_iterator_tag : public input_iterator_tag { };
+
+
+
+  struct bidirectional_iterator_tag : public forward_iterator_tag { };
+
+
+
+  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
+# 106 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
+  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
+           typename _Pointer = _Tp*, typename _Reference = _Tp&>
+    struct iterator
+    {
+
+      typedef _Category iterator_category;
+
+      typedef _Tp value_type;
+
+      typedef _Distance difference_type;
+
+      typedef _Pointer pointer;
+
+      typedef _Reference reference;
+    };
+# 130 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_types.h" 3
+  template<typename _Iterator>
+    struct iterator_traits
+    {
+      typedef typename _Iterator::iterator_category iterator_category;
+      typedef typename _Iterator::value_type value_type;
+      typedef typename _Iterator::difference_type difference_type;
+      typedef typename _Iterator::pointer pointer;
+      typedef typename _Iterator::reference reference;
+    };
+
+
+  template<typename _Tp>
+    struct iterator_traits<_Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+    };
+
+
+  template<typename _Tp>
+    struct iterator_traits<const _Tp*>
+    {
+      typedef random_access_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef ptrdiff_t difference_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+    };
+
+
+
+
+
+  template<typename _Iter>
+    inline typename iterator_traits<_Iter>::iterator_category
+    __iterator_category(const _Iter&)
+    { return typename iterator_traits<_Iter>::iterator_category(); }
+
+
+
+}
+# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
+       
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    __distance(_InputIterator __first, _InputIterator __last,
+               input_iterator_tag)
+    {
+
+     
+
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      while (__first != __last)
+ {
+   ++__first;
+   ++__n;
+ }
+      return __n;
+    }
+
+  template<typename _RandomAccessIterator>
+    inline typename iterator_traits<_RandomAccessIterator>::difference_type
+    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
+               random_access_iterator_tag)
+    {
+
+     
+
+      return __last - __first;
+    }
+# 108 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator>
+    inline typename iterator_traits<_InputIterator>::difference_type
+    distance(_InputIterator __first, _InputIterator __last)
+    {
+
+      return std::__distance(__first, __last,
+        std::__iterator_category(__first));
+    }
+
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
+    {
+
+     
+      while (__n--)
+ ++__i;
+    }
+
+  template<typename _BidirectionalIterator, typename _Distance>
+    inline void
+    __advance(_BidirectionalIterator& __i, _Distance __n,
+       bidirectional_iterator_tag)
+    {
+
+     
+
+      if (__n > 0)
+        while (__n--)
+   ++__i;
+      else
+        while (__n++)
+   --__i;
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline void
+    __advance(_RandomAccessIterator& __i, _Distance __n,
+              random_access_iterator_tag)
+    {
+
+     
+
+      __i += __n;
+    }
+# 166 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
+  template<typename _InputIterator, typename _Distance>
+    inline void
+    advance(_InputIterator& __i, _Distance __n)
+    {
+
+      typename iterator_traits<_InputIterator>::difference_type __d = __n;
+      std::__advance(__i, __d, std::__iterator_category(__i));
+    }
+# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator_base_funcs.h" 3
+}
+# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 1 3
+# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 94 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    class reverse_iterator
+    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
+        typename iterator_traits<_Iterator>::value_type,
+        typename iterator_traits<_Iterator>::difference_type,
+        typename iterator_traits<_Iterator>::pointer,
+                      typename iterator_traits<_Iterator>::reference>
+    {
+    public:
+      _Iterator current;
+
+      typedef iterator_traits<_Iterator> __traits_type;
+
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::pointer pointer;
+      typedef typename __traits_type::reference reference;
+
+
+
+
+
+
+
+      reverse_iterator() : current() { }
+
+
+
+
+      explicit
+      reverse_iterator(iterator_type __x) : current(__x) { }
+
+
+
+
+      reverse_iterator(const reverse_iterator& __x)
+      : current(__x.current) { }
+
+
+
+
+
+      template<typename _Iter>
+        reverse_iterator(const reverse_iterator<_Iter>& __x)
+ : current(__x.base()) { }
+
+
+
+
+      iterator_type
+      base() const
+      { return current; }
+
+
+
+
+
+
+      reference
+      operator*() const
+      {
+ _Iterator __tmp = current;
+ return *--__tmp;
+      }
+
+
+
+
+
+
+      pointer
+      operator->() const
+      { return &(operator*()); }
+
+
+
+
+
+
+      reverse_iterator&
+      operator++()
+      {
+ --current;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator++(int)
+      {
+ reverse_iterator __tmp = *this;
+ --current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      reverse_iterator&
+      operator--()
+      {
+ ++current;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator--(int)
+      {
+ reverse_iterator __tmp = *this;
+ ++current;
+ return __tmp;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator+(difference_type __n) const
+      { return reverse_iterator(current - __n); }
+
+
+
+
+
+
+      reverse_iterator&
+      operator+=(difference_type __n)
+      {
+ current -= __n;
+ return *this;
+      }
+
+
+
+
+
+
+      reverse_iterator
+      operator-(difference_type __n) const
+      { return reverse_iterator(current + __n); }
+
+
+
+
+
+
+      reverse_iterator&
+      operator-=(difference_type __n)
+      {
+ current += __n;
+ return *this;
+      }
+
+
+
+
+
+
+      reference
+      operator[](difference_type __n) const
+      { return *(*this + __n); }
+    };
+# 281 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Iterator>
+    inline bool
+    operator==(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator<(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _Iterator>
+    inline bool
+    operator!=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y < __x; }
+
+  template<typename _Iterator>
+    inline bool
+    operator<=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Iterator>
+    inline bool
+    operator>=(const reverse_iterator<_Iterator>& __x,
+        const reverse_iterator<_Iterator>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Iterator>
+    inline typename reverse_iterator<_Iterator>::difference_type
+    operator-(const reverse_iterator<_Iterator>& __x,
+       const reverse_iterator<_Iterator>& __y)
+    { return __y.base() - __x.base(); }
+
+  template<typename _Iterator>
+    inline reverse_iterator<_Iterator>
+    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
+       const reverse_iterator<_Iterator>& __x)
+    { return reverse_iterator<_Iterator>(__x.base() - __n); }
+
+
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator==(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return __x.base() == __y.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y.base() < __x.base(); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator!=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x == __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+    { return __y < __x; }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator<=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__y < __x); }
+
+  template<typename _IteratorL, typename _IteratorR>
+    inline bool
+    operator>=(const reverse_iterator<_IteratorL>& __x,
+        const reverse_iterator<_IteratorR>& __y)
+    { return !(__x < __y); }
+
+  template<typename _IteratorL, typename _IteratorR>
+
+
+
+
+
+
+
+    inline typename reverse_iterator<_IteratorL>::difference_type
+    operator-(const reverse_iterator<_IteratorL>& __x,
+       const reverse_iterator<_IteratorR>& __y)
+
+    { return __y.base() - __x.base(); }
+# 393 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class back_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      _Container* container;
+
+    public:
+
+      typedef _Container container_type;
+
+
+      explicit
+      back_insert_iterator(_Container& __x) : container(&__x) { }
+# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+      back_insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+ container->push_back(__value);
+ return *this;
+      }
+# 436 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+      back_insert_iterator&
+      operator*()
+      { return *this; }
+
+
+      back_insert_iterator&
+      operator++()
+      { return *this; }
+
+
+      back_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+# 462 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Container>
+    inline back_insert_iterator<_Container>
+    back_inserter(_Container& __x)
+    { return back_insert_iterator<_Container>(__x); }
+# 477 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class front_insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      _Container* container;
+
+    public:
+
+      typedef _Container container_type;
+
+
+      explicit front_insert_iterator(_Container& __x) : container(&__x) { }
+# 502 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+      front_insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+ container->push_front(__value);
+ return *this;
+      }
+# 519 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+      front_insert_iterator&
+      operator*()
+      { return *this; }
+
+
+      front_insert_iterator&
+      operator++()
+      { return *this; }
+
+
+      front_insert_iterator
+      operator++(int)
+      { return *this; }
+    };
+# 545 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Container>
+    inline front_insert_iterator<_Container>
+    front_inserter(_Container& __x)
+    { return front_insert_iterator<_Container>(__x); }
+# 564 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Container>
+    class insert_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+      _Container* container;
+      typename _Container::iterator iter;
+
+    public:
+
+      typedef _Container container_type;
+
+
+
+
+
+      insert_iterator(_Container& __x, typename _Container::iterator __i)
+      : container(&__x), iter(__i) {}
+# 606 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+      insert_iterator&
+      operator=(typename _Container::const_reference __value)
+      {
+ iter = container->insert(iter, __value);
+ ++iter;
+ return *this;
+      }
+# 625 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+      insert_iterator&
+      operator*()
+      { return *this; }
+
+
+      insert_iterator&
+      operator++()
+      { return *this; }
+
+
+      insert_iterator&
+      operator++(int)
+      { return *this; }
+    };
+# 651 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _Container, typename _Iterator>
+    inline insert_iterator<_Container>
+    inserter(_Container& __x, _Iterator __i)
+    {
+      return insert_iterator<_Container>(__x,
+      typename _Container::iterator(__i));
+    }
+
+
+
+}
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  using std::iterator_traits;
+  using std::iterator;
+  template<typename _Iterator, typename _Container>
+    class __normal_iterator
+    {
+    public:
+      _Iterator _M_current;
+
+      typedef iterator_traits<_Iterator> __traits_type;
+
+    public:
+      typedef _Iterator iterator_type;
+      typedef typename __traits_type::iterator_category iterator_category;
+      typedef typename __traits_type::value_type value_type;
+      typedef typename __traits_type::difference_type difference_type;
+      typedef typename __traits_type::reference reference;
+      typedef typename __traits_type::pointer pointer;
+
+      __normal_iterator() : _M_current(_Iterator()) { }
+
+      explicit
+      __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
+
+
+      template<typename _Iter>
+        __normal_iterator(const __normal_iterator<_Iter,
+     typename __enable_if<
+              (std::__are_same<_Iter, typename _Container::pointer>::__value),
+        _Container>::__type>& __i)
+        : _M_current(__i.base()) { }
+
+
+      reference
+      operator*() const
+      { return *_M_current; }
+
+      pointer
+      operator->() const
+      { return _M_current; }
+
+      __normal_iterator&
+      operator++()
+      {
+ ++_M_current;
+ return *this;
+      }
+
+      __normal_iterator
+      operator++(int)
+      { return __normal_iterator(_M_current++); }
+
+
+      __normal_iterator&
+      operator--()
+      {
+ --_M_current;
+ return *this;
+      }
+
+      __normal_iterator
+      operator--(int)
+      { return __normal_iterator(_M_current--); }
+
+
+      reference
+      operator[](const difference_type& __n) const
+      { return _M_current[__n]; }
+
+      __normal_iterator&
+      operator+=(const difference_type& __n)
+      { _M_current += __n; return *this; }
+
+      __normal_iterator
+      operator+(const difference_type& __n) const
+      { return __normal_iterator(_M_current + __n); }
+
+      __normal_iterator&
+      operator-=(const difference_type& __n)
+      { _M_current -= __n; return *this; }
+
+      __normal_iterator
+      operator-(const difference_type& __n) const
+      { return __normal_iterator(_M_current - __n); }
+
+      const _Iterator&
+      base() const
+      { return _M_current; }
+    };
+# 770 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_iterator.h" 3
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() == __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() != __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() != __rhs.base(); }
+
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() < __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() > __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() <= __rhs.base(); }
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
+        const __normal_iterator<_IteratorR, _Container>& __rhs)
+    { return __lhs.base() >= __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline bool
+    operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
+        const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() >= __rhs.base(); }
+
+
+
+
+
+  template<typename _IteratorL, typename _IteratorR, typename _Container>
+
+
+
+
+
+
+
+    inline typename __normal_iterator<_IteratorL, _Container>::difference_type
+    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
+       const __normal_iterator<_IteratorR, _Container>& __rhs)
+
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline typename __normal_iterator<_Iterator, _Container>::difference_type
+    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
+       const __normal_iterator<_Iterator, _Container>& __rhs)
+    { return __lhs.base() - __rhs.base(); }
+
+  template<typename _Iterator, typename _Container>
+    inline __normal_iterator<_Iterator, _Container>
+    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
+       __n, const __normal_iterator<_Iterator, _Container>& __i)
+    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
+
+}
+# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/debug/debug.h" 1 3
+# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/debug/debug.h" 3
+namespace std
+{
+  namespace __debug { }
+}
+
+
+
+
+namespace __gnu_debug
+{
+  using namespace std::__debug;
+}
+# 72 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+  template<bool _BoolType>
+    struct __iter_swap
+    {
+      template<typename _ForwardIterator1, typename _ForwardIterator2>
+        static void
+        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+        {
+          typedef typename iterator_traits<_ForwardIterator1>::value_type
+            _ValueType1;
+          _ValueType1 __tmp = (*__a);
+          *__a = (*__b);
+          *__b = (__tmp);
+ }
+    };
+
+  template<>
+    struct __iter_swap<true>
+    {
+      template<typename _ForwardIterator1, typename _ForwardIterator2>
+        static void
+        iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+        {
+          swap(*__a, *__b);
+        }
+    };
+# 115 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline void
+    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
+    {
+      typedef typename iterator_traits<_ForwardIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator2>::value_type
+ _ValueType2;
+
+
+     
+
+     
+
+     
+
+     
+
+
+      typedef typename iterator_traits<_ForwardIterator1>::reference
+ _ReferenceType1;
+      typedef typename iterator_traits<_ForwardIterator2>::reference
+ _ReferenceType2;
+      std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value
+ && __are_same<_ValueType1&, _ReferenceType1>::__value
+ && __are_same<_ValueType2&, _ReferenceType2>::__value>::
+ iter_swap(__a, __b);
+    }
+# 156 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator2
+    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+  _ForwardIterator2 __first2)
+    {
+
+     
+
+     
+
+      ;
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ std::iter_swap(__first1, __first2);
+      return __first2;
+    }
+# 184 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _Tp>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b)
+    {
+
+     
+
+      if (__b < __a)
+ return __b;
+      return __a;
+    }
+# 207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _Tp>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b)
+    {
+
+     
+
+      if (__a < __b)
+ return __b;
+      return __a;
+    }
+# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _Tp, typename _Compare>
+    inline const _Tp&
+    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+
+      if (__comp(__b, __a))
+ return __b;
+      return __a;
+    }
+# 251 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _Tp, typename _Compare>
+    inline const _Tp&
+    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
+    {
+
+      if (__comp(__a, __b))
+ return __b;
+      return __a;
+    }
+
+
+
+
+  template<typename _Iterator, bool _HasBase>
+    struct _Iter_base
+    {
+      typedef _Iterator iterator_type;
+      static iterator_type
+      _S_base(_Iterator __it)
+      { return __it; }
+    };
+
+  template<typename _Iterator>
+    struct _Iter_base<_Iterator, true>
+    {
+      typedef typename _Iterator::iterator_type iterator_type;
+      static iterator_type
+      _S_base(_Iterator __it)
+      { return __it.base(); }
+    };
+
+
+
+  template<typename _Iterator>
+    struct _Niter_base
+    : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value>
+    { };
+
+  template<typename _Iterator>
+    inline typename _Niter_base<_Iterator>::iterator_type
+    __niter_base(_Iterator __it)
+    { return std::_Niter_base<_Iterator>::_S_base(__it); }
+
+
+  template<typename _Iterator>
+    struct _Miter_base
+    : _Iter_base<_Iterator, __is_move_iterator<_Iterator>::__value>
+    { };
+
+  template<typename _Iterator>
+    inline typename _Miter_base<_Iterator>::iterator_type
+    __miter_base(_Iterator __it)
+    { return std::_Miter_base<_Iterator>::_S_base(__it); }
+
+
+
+
+
+
+
+  template<bool, bool, typename>
+    struct __copy_move
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   for (; __first != __last; ++__result, ++__first)
+     *__result = *__first;
+   return __result;
+ }
+    };
+# 339 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<>
+    struct __copy_move<false, false, random_access_iterator_tag>
+    {
+      template<typename _II, typename _OI>
+        static _OI
+        __copy_m(_II __first, _II __last, _OI __result)
+        {
+   typedef typename iterator_traits<_II>::difference_type _Distance;
+   for(_Distance __n = __last - __first; __n > 0; --__n)
+     {
+       *__result = *__first;
+       ++__first;
+       ++__result;
+     }
+   return __result;
+ }
+    };
+# 377 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<bool _IsMove>
+    struct __copy_move<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
+   return __result + _Num;
+ }
+    };
+
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a(_II __first, _II __last, _OI __result)
+    {
+      typedef typename iterator_traits<_II>::value_type _ValueTypeI;
+      typedef typename iterator_traits<_OI>::value_type _ValueTypeO;
+      typedef typename iterator_traits<_II>::iterator_category _Category;
+      const bool __simple = (__is_pod(_ValueTypeI)
+                      && __is_pointer<_II>::__value
+                      && __is_pointer<_OI>::__value
+        && __are_same<_ValueTypeI, _ValueTypeO>::__value);
+
+      return std::__copy_move<_IsMove, __simple,
+                       _Category>::__copy_m(__first, __last, __result);
+    }
+
+
+
+  template<typename _CharT>
+    struct char_traits;
+
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator;
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(_CharT*, _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
+    __copy_move_a2(const _CharT*, const _CharT*,
+     ostreambuf_iterator<_CharT, char_traits<_CharT> >);
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
+     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);
+
+  template<bool _IsMove, typename _II, typename _OI>
+    inline _OI
+    __copy_move_a2(_II __first, _II __last, _OI __result)
+    {
+      return _OI(std::__copy_move_a<_IsMove>(std::__niter_base(__first),
+          std::__niter_base(__last),
+          std::__niter_base(__result)));
+    }
+# 462 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _II, typename _OI>
+    inline _OI
+    copy(_II __first, _II __last, _OI __result)
+    {
+
+     
+     
+
+      ;
+
+      return (std::__copy_move_a2<__is_move_iterator<_II>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<bool, bool, typename>
+    struct __copy_move_backward
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   while (__first != __last)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+# 542 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<>
+    struct __copy_move_backward<false, false, random_access_iterator_tag>
+    {
+      template<typename _BI1, typename _BI2>
+        static _BI2
+        __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
+        {
+   typename iterator_traits<_BI1>::difference_type __n;
+   for (__n = __last - __first; __n > 0; --__n)
+     *--__result = *--__last;
+   return __result;
+ }
+    };
+# 572 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<bool _IsMove>
+    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
+    {
+      template<typename _Tp>
+        static _Tp*
+        __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result)
+        {
+   const ptrdiff_t _Num = __last - __first;
+   if (_Num)
+     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
+   return __result - _Num;
+ }
+    };
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      typedef typename iterator_traits<_BI1>::value_type _ValueType1;
+      typedef typename iterator_traits<_BI2>::value_type _ValueType2;
+      typedef typename iterator_traits<_BI1>::iterator_category _Category;
+      const bool __simple = (__is_pod(_ValueType1)
+                      && __is_pointer<_BI1>::__value
+                      && __is_pointer<_BI2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+
+      return std::__copy_move_backward<_IsMove, __simple,
+                                _Category>::__copy_move_b(__first,
+         __last,
+         __result);
+    }
+
+  template<bool _IsMove, typename _BI1, typename _BI2>
+    inline _BI2
+    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+      return _BI2(std::__copy_move_backward_a<_IsMove>
+    (std::__niter_base(__first), std::__niter_base(__last),
+     std::__niter_base(__result)));
+    }
+# 631 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _BI1, typename _BI2>
+    inline _BI2
+    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value>
+       (std::__miter_base(__first), std::__miter_base(__last),
+        __result));
+    }
+# 689 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+       const _Tp& __value)
+    {
+      for (; __first != __last; ++__first)
+ *__first = __value;
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
+    __fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __first != __last; ++__first)
+ *__first = __tmp;
+    }
+
+
+  template<typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
+    __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c)
+    {
+      const _Tp __tmp = __c;
+      __builtin_memset(__first, static_cast<unsigned char>(__tmp),
+         __last - __first);
+    }
+# 733 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
+    {
+
+     
+
+      ;
+
+      std::__fill_a(std::__niter_base(__first), std::__niter_base(__last),
+      __value);
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      for (; __n > 0; --__n, ++__first)
+ *__first = __value;
+      return __first;
+    }
+
+  template<typename _OutputIterator, typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
+    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value)
+    {
+      const _Tp __tmp = __value;
+      for (; __n > 0; --__n, ++__first)
+ *__first = __tmp;
+      return __first;
+    }
+
+  template<typename _Size, typename _Tp>
+    inline typename
+    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type
+    __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c)
+    {
+      std::__fill_a(__first, __first + __n, __c);
+      return __first + __n;
+    }
+# 791 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _OI, typename _Size, typename _Tp>
+    inline _OI
+    fill_n(_OI __first, _Size __n, const _Tp& __value)
+    {
+
+     
+
+      return _OI(std::__fill_n_a(std::__niter_base(__first), __n, __value));
+    }
+
+  template<bool _BoolType>
+    struct __equal
+    {
+      template<typename _II1, typename _II2>
+        static bool
+        equal(_II1 __first1, _II1 __last1, _II2 __first2)
+        {
+   for (; __first1 != __last1; ++__first1, ++__first2)
+     if (!(*__first1 == *__first2))
+       return false;
+   return true;
+ }
+    };
+
+  template<>
+    struct __equal<true>
+    {
+      template<typename _Tp>
+        static bool
+        equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
+        {
+   return !__builtin_memcmp(__first1, __first2, sizeof(_Tp)
+       * (__last1 - __first1));
+ }
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple = (__is_integer<_ValueType1>::__value
+                      && __is_pointer<_II1>::__value
+                      && __is_pointer<_II2>::__value
+        && __are_same<_ValueType1, _ValueType2>::__value);
+
+      return std::__equal<__simple>::equal(__first1, __last1, __first2);
+    }
+
+
+  template<typename, typename>
+    struct __lc_rai
+    {
+      template<typename _II1, typename _II2>
+        static _II1
+        __newlast1(_II1, _II1 __last1, _II2, _II2)
+        { return __last1; }
+
+      template<typename _II>
+        static bool
+        __cnd2(_II __first, _II __last)
+        { return __first != __last; }
+    };
+
+  template<>
+    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
+    {
+      template<typename _RAI1, typename _RAI2>
+        static _RAI1
+        __newlast1(_RAI1 __first1, _RAI1 __last1,
+     _RAI2 __first2, _RAI2 __last2)
+        {
+   const typename iterator_traits<_RAI1>::difference_type
+     __diff1 = __last1 - __first1;
+   const typename iterator_traits<_RAI2>::difference_type
+     __diff2 = __last2 - __first2;
+   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
+ }
+
+      template<typename _RAI>
+        static bool
+        __cnd2(_RAI, _RAI)
+        { return true; }
+    };
+
+  template<bool _BoolType>
+    struct __lexicographical_compare
+    {
+      template<typename _II1, typename _II2>
+        static bool __lc(_II1, _II1, _II2, _II2);
+    };
+
+  template<bool _BoolType>
+    template<typename _II1, typename _II2>
+      bool
+      __lexicographical_compare<_BoolType>::
+      __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
+      {
+ typedef typename iterator_traits<_II1>::iterator_category _Category1;
+ typedef typename iterator_traits<_II2>::iterator_category _Category2;
+ typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+
+ __last1 = __rai_type::__newlast1(__first1, __last1,
+      __first2, __last2);
+ for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+      ++__first1, ++__first2)
+   {
+     if (*__first1 < *__first2)
+       return true;
+     if (*__first2 < *__first1)
+       return false;
+   }
+ return __first1 == __last1 && __first2 != __last2;
+      }
+
+  template<>
+    struct __lexicographical_compare<true>
+    {
+      template<typename _Tp, typename _Up>
+        static bool
+        __lc(const _Tp* __first1, const _Tp* __last1,
+      const _Up* __first2, const _Up* __last2)
+ {
+   const size_t __len1 = __last1 - __first1;
+   const size_t __len2 = __last2 - __first2;
+   const int __result = __builtin_memcmp(__first1, __first2,
+      std::min(__len1, __len2));
+   return __result != 0 ? __result < 0 : __len1 < __len2;
+ }
+    };
+
+  template<typename _II1, typename _II2>
+    inline bool
+    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
+      _II2 __first2, _II2 __last2)
+    {
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+      const bool __simple =
+ (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value
+  && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed
+  && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed
+  && __is_pointer<_II1>::__value
+  && __is_pointer<_II2>::__value);
+
+      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
+           __first2, __last2);
+    }
+# 952 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+      ;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle;
+
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (*__middle < __val)
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+
+
+
+  template<typename _Size>
+    inline _Size
+    __lg(_Size __n)
+    {
+      _Size __k;
+      for (__k = 0; __n != 0; __n >>= 1)
+ ++__k;
+      return __k - 1;
+    }
+
+  inline int
+  __lg(int __n)
+  { return sizeof(int) * 8 - 1 - __builtin_clz(__n); }
+
+  inline long
+  __lg(long __n)
+  { return sizeof(long) * 8 - 1 - __builtin_clzl(__n); }
+
+  inline long long
+  __lg(long long __n)
+  { return sizeof(long long) * 8 - 1 - __builtin_clzll(__n); }
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 1028 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+    inline bool
+    equal(_II1 __first1, _II1 __last1, _II2 __first2)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      return std::__equal_aux(std::__niter_base(__first1),
+         std::__niter_base(__last1),
+         std::__niter_base(__first2));
+    }
+# 1060 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    inline bool
+    equal(_IIter1 __first1, _IIter1 __last1,
+   _IIter2 __first2, _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+      ;
+
+      for (; __first1 != __last1; ++__first1, ++__first2)
+ if (!bool(__binary_pred(*__first1, *__first2)))
+   return false;
+      return true;
+    }
+# 1091 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2>
+    inline bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2)
+    {
+
+      typedef typename iterator_traits<_II1>::value_type _ValueType1;
+      typedef typename iterator_traits<_II2>::value_type _ValueType2;
+     
+     
+     
+     
+      ;
+      ;
+
+      return std::__lexicographical_compare_aux(std::__niter_base(__first1),
+      std::__niter_base(__last1),
+      std::__niter_base(__first2),
+      std::__niter_base(__last2));
+    }
+# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _II1, typename _II2, typename _Compare>
+    bool
+    lexicographical_compare(_II1 __first1, _II1 __last1,
+       _II2 __first2, _II2 __last2, _Compare __comp)
+    {
+      typedef typename iterator_traits<_II1>::iterator_category _Category1;
+      typedef typename iterator_traits<_II2>::iterator_category _Category2;
+      typedef std::__lc_rai<_Category1, _Category2> __rai_type;
+
+
+     
+     
+      ;
+      ;
+
+      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
+      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
+    ++__first1, ++__first2)
+ {
+   if (__comp(*__first1, *__first2))
+     return true;
+   if (__comp(*__first2, *__first1))
+     return false;
+ }
+      return __first1 == __last1 && __first2 != __last2;
+    }
+# 1165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      while (__first1 != __last1 && *__first1 == *__first2)
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+# 1202 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algobase.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _BinaryPredicate>
+    pair<_InputIterator1, _InputIterator2>
+    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+      ;
+
+      while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2)))
+        {
+   ++__first1;
+   ++__first2;
+        }
+      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
+    }
+
+}
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 1 3
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+       
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 37 "/usr/include/wchar.h" 3 4
+# 1 "/usr/include/stdio.h" 1 3 4
+# 45 "/usr/include/stdio.h" 3 4
+struct _IO_FILE;
+
+
+
+typedef struct _IO_FILE FILE;
+
+
+
+
+
+# 65 "/usr/include/stdio.h" 3 4
+typedef struct _IO_FILE __FILE;
+# 38 "/usr/include/wchar.h" 2 3 4
+
+
+
+
+# 1 "/usr/include/bits/wchar.h" 1 3 4
+# 43 "/usr/include/wchar.h" 2 3 4
+# 52 "/usr/include/wchar.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 352 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 3 4
+typedef unsigned int wint_t;
+# 53 "/usr/include/wchar.h" 2 3 4
+# 83 "/usr/include/wchar.h" 3 4
+typedef struct
+{
+  int __count;
+  union
+  {
+
+    unsigned int __wch;
+
+
+
+    char __wchb[4];
+  } __value;
+} __mbstate_t;
+# 104 "/usr/include/wchar.h" 3 4
+
+
+typedef __mbstate_t mbstate_t;
+
+
+
+# 129 "/usr/include/wchar.h" 3 4
+extern "C" {
+
+
+
+
+struct tm;
+
+
+
+
+
+
+
+
+
+extern wchar_t *wcscpy (wchar_t *__restrict __dest,
+   __const wchar_t *__restrict __src) throw ();
+
+extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
+    __const wchar_t *__restrict __src, size_t __n)
+     throw ();
+
+
+extern wchar_t *wcscat (wchar_t *__restrict __dest,
+   __const wchar_t *__restrict __src) throw ();
+
+extern wchar_t *wcsncat (wchar_t *__restrict __dest,
+    __const wchar_t *__restrict __src, size_t __n)
+     throw ();
+
+
+extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
+     throw () __attribute__ ((__pure__));
+
+extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) throw ();
+
+
+extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2,
+   size_t __n) throw ();
+
+
+
+
+
+extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
+    __locale_t __loc) throw ();
+
+extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
+     size_t __n, __locale_t __loc) throw ();
+
+
+
+
+
+extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) throw ();
+
+
+
+extern size_t wcsxfrm (wchar_t *__restrict __s1,
+         __const wchar_t *__restrict __s2, size_t __n) throw ();
+
+
+
+
+
+
+
+
+extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
+        __locale_t __loc) throw ();
+
+
+
+
+extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
+    size_t __n, __locale_t __loc) throw ();
+
+
+extern wchar_t *wcsdup (__const wchar_t *__s) throw () __attribute__ ((__malloc__));
+
+
+
+
+
+extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcschr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
+     throw () __asm ("wcsrchr") __attribute__ ((__pure__));
+
+
+
+
+
+
+
+
+
+extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject)
+     throw () __attribute__ ((__pure__));
+
+
+extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
+     throw () __attribute__ ((__pure__));
+
+
+extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, __const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcspbrk (__const wchar_t *__wcs,
+           __const wchar_t *__accept)
+     throw () __asm ("wcspbrk") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wcsstr (wchar_t *__haystack, __const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcsstr (__const wchar_t *__haystack,
+          __const wchar_t *__needle)
+     throw () __asm ("wcsstr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern wchar_t *wcstok (wchar_t *__restrict __s,
+   __const wchar_t *__restrict __delim,
+   wchar_t **__restrict __ptr) throw ();
+
+
+extern size_t wcslen (__const wchar_t *__s) throw () __attribute__ ((__pure__));
+
+
+
+
+
+extern "C++" wchar_t *wcswcs (wchar_t *__haystack, __const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wcswcs (__const wchar_t *__haystack,
+          __const wchar_t *__needle)
+     throw () __asm ("wcswcs") __attribute__ ((__pure__));
+# 303 "/usr/include/wchar.h" 3 4
+extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
+     throw () __attribute__ ((__pure__));
+
+
+
+
+
+
+extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+extern "C++" __const wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c,
+           size_t __n)
+     throw () __asm ("wmemchr") __attribute__ ((__pure__));
+
+
+
+
+
+
+extern int wmemcmp (__const wchar_t *__restrict __s1,
+      __const wchar_t *__restrict __s2, size_t __n)
+     throw () __attribute__ ((__pure__));
+
+
+extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
+    __const wchar_t *__restrict __s2, size_t __n) throw ();
+
+
+
+extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n)
+     throw ();
+
+
+extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
+
+
+
+
+
+extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
+     __const wchar_t *__restrict __s2, size_t __n)
+     throw ();
+
+
+
+
+
+
+extern wint_t btowc (int __c) throw ();
+
+
+
+extern int wctob (wint_t __c) throw ();
+
+
+
+extern int mbsinit (__const mbstate_t *__ps) throw () __attribute__ ((__pure__));
+
+
+
+extern size_t mbrtowc (wchar_t *__restrict __pwc,
+         __const char *__restrict __s, size_t __n,
+         mbstate_t *__p) throw ();
+
+
+extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
+         mbstate_t *__restrict __ps) throw ();
+
+
+extern size_t __mbrlen (__const char *__restrict __s, size_t __n,
+   mbstate_t *__restrict __ps) throw ();
+extern size_t mbrlen (__const char *__restrict __s, size_t __n,
+        mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+
+
+
+extern wint_t __btowc_alias (int __c) __asm ("btowc");
+extern __inline __attribute__ ((__gnu_inline__)) wint_t
+btowc (int __c) throw ()
+{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
+   ? (wint_t) __c : __btowc_alias (__c)); }
+
+extern int __wctob_alias (wint_t __c) __asm ("wctob");
+extern __inline __attribute__ ((__gnu_inline__)) int
+wctob (wint_t __wc) throw ()
+{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
+   ? (int) __wc : __wctob_alias (__wc)); }
+
+extern __inline __attribute__ ((__gnu_inline__)) size_t
+mbrlen (__const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) throw ()
+
+{ return (__ps != __null
+   ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }
+
+
+
+
+
+extern size_t mbsrtowcs (wchar_t *__restrict __dst,
+    __const char **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+
+
+
+extern size_t wcsrtombs (char *__restrict __dst,
+    __const wchar_t **__restrict __src, size_t __len,
+    mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+
+extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
+     __const char **__restrict __src, size_t __nmc,
+     size_t __len, mbstate_t *__restrict __ps) throw ();
+
+
+
+extern size_t wcsnrtombs (char *__restrict __dst,
+     __const wchar_t **__restrict __src,
+     size_t __nwc, size_t __len,
+     mbstate_t *__restrict __ps) throw ();
+
+
+
+
+
+
+extern int wcwidth (wchar_t __c) throw ();
+
+
+
+extern int wcswidth (__const wchar_t *__s, size_t __n) throw ();
+
+
+
+
+
+
+extern double wcstod (__const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr) throw ();
+
+
+
+
+
+extern float wcstof (__const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+extern long double wcstold (__const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr) throw ();
+
+
+
+
+
+
+
+extern long int wcstol (__const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, int __base) throw ();
+
+
+
+extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
+      wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+
+
+
+__extension__
+extern long long int wcstoll (__const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+__extension__
+extern unsigned long long int wcstoull (__const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr,
+     int __base) throw ();
+
+
+
+
+
+
+__extension__
+extern long long int wcstoq (__const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr, int __base)
+     throw ();
+
+
+
+__extension__
+extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr,
+           wchar_t **__restrict __endptr,
+           int __base) throw ();
+# 528 "/usr/include/wchar.h" 3 4
+extern long int wcstol_l (__const wchar_t *__restrict __nptr,
+     wchar_t **__restrict __endptr, int __base,
+     __locale_t __loc) throw ();
+
+extern unsigned long int wcstoul_l (__const wchar_t *__restrict __nptr,
+        wchar_t **__restrict __endptr,
+        int __base, __locale_t __loc) throw ();
+
+__extension__
+extern long long int wcstoll_l (__const wchar_t *__restrict __nptr,
+    wchar_t **__restrict __endptr,
+    int __base, __locale_t __loc) throw ();
+
+__extension__
+extern unsigned long long int wcstoull_l (__const wchar_t *__restrict __nptr,
+       wchar_t **__restrict __endptr,
+       int __base, __locale_t __loc)
+     throw ();
+
+extern double wcstod_l (__const wchar_t *__restrict __nptr,
+   wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+
+extern float wcstof_l (__const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr, __locale_t __loc)
+     throw ();
+
+extern long double wcstold_l (__const wchar_t *__restrict __nptr,
+         wchar_t **__restrict __endptr,
+         __locale_t __loc) throw ();
+
+
+
+
+
+
+extern wchar_t *wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ();
+
+
+
+extern wchar_t *wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n)
+     throw ();
+# 578 "/usr/include/wchar.h" 3 4
+extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
+
+
+
+
+
+
+extern int fwide (__FILE *__fp, int __mode) throw ();
+
+
+
+
+
+
+extern int fwprintf (__FILE *__restrict __stream,
+       __const wchar_t *__restrict __format, ...)
+                                                           ;
+
+
+
+
+extern int wprintf (__const wchar_t *__restrict __format, ...)
+                                                           ;
+
+extern int swprintf (wchar_t *__restrict __s, size_t __n,
+       __const wchar_t *__restrict __format, ...)
+     throw () ;
+
+
+
+
+
+extern int vfwprintf (__FILE *__restrict __s,
+        __const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+                                                           ;
+
+
+
+
+extern int vwprintf (__const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                           ;
+
+
+extern int vswprintf (wchar_t *__restrict __s, size_t __n,
+        __const wchar_t *__restrict __format,
+        __gnuc_va_list __arg)
+     throw () ;
+
+
+
+
+
+
+extern int fwscanf (__FILE *__restrict __stream,
+      __const wchar_t *__restrict __format, ...)
+                                                          ;
+
+
+
+
+extern int wscanf (__const wchar_t *__restrict __format, ...)
+                                                          ;
+
+extern int swscanf (__const wchar_t *__restrict __s,
+      __const wchar_t *__restrict __format, ...)
+     throw () ;
+# 678 "/usr/include/wchar.h" 3 4
+
+
+
+
+
+
+
+
+
+extern int vfwscanf (__FILE *__restrict __s,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+                                                          ;
+
+
+
+
+extern int vwscanf (__const wchar_t *__restrict __format,
+      __gnuc_va_list __arg)
+                                                          ;
+
+extern int vswscanf (__const wchar_t *__restrict __s,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+# 734 "/usr/include/wchar.h" 3 4
+
+
+
+
+
+
+
+
+
+extern wint_t fgetwc (__FILE *__stream);
+extern wint_t getwc (__FILE *__stream);
+
+
+
+
+
+extern wint_t getwchar (void);
+
+
+
+
+
+
+extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
+extern wint_t putwc (wchar_t __wc, __FILE *__stream);
+
+
+
+
+
+extern wint_t putwchar (wchar_t __wc);
+
+
+
+
+
+
+
+extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
+   __FILE *__restrict __stream);
+
+
+
+
+
+extern int fputws (__const wchar_t *__restrict __ws,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
+
+# 799 "/usr/include/wchar.h" 3 4
+extern wint_t getwc_unlocked (__FILE *__stream);
+extern wint_t getwchar_unlocked (void);
+
+
+
+
+
+
+
+extern wint_t fgetwc_unlocked (__FILE *__stream);
+
+
+
+
+
+
+
+extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
+# 825 "/usr/include/wchar.h" 3 4
+extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
+extern wint_t putwchar_unlocked (wchar_t __wc);
+# 835 "/usr/include/wchar.h" 3 4
+extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
+     __FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern int fputws_unlocked (__const wchar_t *__restrict __ws,
+       __FILE *__restrict __stream);
+
+
+
+
+
+
+
+extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
+   __const wchar_t *__restrict __format,
+   __const struct tm *__restrict __tp) throw ();
+
+
+
+
+
+
+
+extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
+     __const wchar_t *__restrict __format,
+     __const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+# 882 "/usr/include/wchar.h" 3 4
+# 1 "/usr/include/bits/wchar2.h" 1 3 4
+# 25 "/usr/include/bits/wchar2.h" 3 4
+extern wchar_t *__wmemcpy_chk (wchar_t *__restrict __s1,
+          __const wchar_t *__restrict __s2, size_t __n,
+          size_t __ns1) throw ();
+extern wchar_t *__wmemcpy_alias (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmemcpy")
+
+
+            ;
+extern wchar_t *__wmemcpy_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemcpy_chk")
+
+
+
+     __attribute__((__warning__ ("wmemcpy called with length bigger than size of destination " "buffer")))
+            ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wmemcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()
+
+{
+  if (__builtin_object_size (__s1, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmemcpy_chk (__s1, __s2, __n,
+         __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+
+      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
+ return __wmemcpy_chk_warn (__s1, __s2, __n,
+       __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+    }
+  return __wmemcpy_alias (__s1, __s2, __n);
+}
+
+
+extern wchar_t *__wmemmove_chk (wchar_t *__s1, __const wchar_t *__s2,
+    size_t __n, size_t __ns1) throw ();
+extern wchar_t *__wmemmove_alias (wchar_t *__s1, __const wchar_t *__s2, size_t __n) throw () __asm__ ("" "wmemmove")
+
+                               ;
+extern wchar_t *__wmemmove_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmemmove_chk")
+
+
+
+     __attribute__((__warning__ ("wmemmove called with length bigger than size of destination " "buffer")))
+            ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wmemmove (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()
+
+{
+  if (__builtin_object_size (__s1, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmemmove_chk (__s1, __s2, __n,
+          __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+
+      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
+ return __wmemmove_chk_warn (__s1, __s2, __n,
+        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+    }
+  return __wmemmove_alias (__s1, __s2, __n);
+}
+
+
+
+extern wchar_t *__wmempcpy_chk (wchar_t *__restrict __s1,
+    __const wchar_t *__restrict __s2, size_t __n,
+    size_t __ns1) throw ();
+extern wchar_t *__wmempcpy_alias (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw () __asm__ ("" "wmempcpy")
+
+
+                           ;
+extern wchar_t *__wmempcpy_chk_warn (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n, size_t __ns1) throw () __asm__ ("" "__wmempcpy_chk")
+
+
+
+     __attribute__((__warning__ ("wmempcpy called with length bigger than size of destination " "buffer")))
+            ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wmempcpy (wchar_t *__restrict __s1, __const wchar_t *__restrict __s2, size_t __n) throw ()
+
+{
+  if (__builtin_object_size (__s1, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmempcpy_chk (__s1, __s2, __n,
+          __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+
+      if (__n > __builtin_object_size (__s1, 0) / sizeof (wchar_t))
+ return __wmempcpy_chk_warn (__s1, __s2, __n,
+        __builtin_object_size (__s1, 0) / sizeof (wchar_t));
+    }
+  return __wmempcpy_alias (__s1, __s2, __n);
+}
+
+
+
+extern wchar_t *__wmemset_chk (wchar_t *__s, wchar_t __c, size_t __n,
+          size_t __ns) throw ();
+extern wchar_t *__wmemset_alias (wchar_t *__s, wchar_t __c, size_t __n) throw () __asm__ ("" "wmemset")
+                             ;
+extern wchar_t *__wmemset_chk_warn (wchar_t *__s, wchar_t __c, size_t __n, size_t __ns) throw () __asm__ ("" "__wmemset_chk")
+
+
+     __attribute__((__warning__ ("wmemset called with length bigger than size of destination " "buffer")))
+            ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wmemset (wchar_t *__restrict __s, wchar_t __c, size_t __n) throw ()
+{
+  if (__builtin_object_size (__s, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wmemset_chk (__s, __c, __n, __builtin_object_size (__s, 0) / sizeof (wchar_t));
+
+      if (__n > __builtin_object_size (__s, 0) / sizeof (wchar_t))
+ return __wmemset_chk_warn (__s, __c, __n,
+       __builtin_object_size (__s, 0) / sizeof (wchar_t));
+    }
+  return __wmemset_alias (__s, __c, __n);
+}
+
+
+extern wchar_t *__wcscpy_chk (wchar_t *__restrict __dest,
+         __const wchar_t *__restrict __src,
+         size_t __n) throw ();
+extern wchar_t *__wcscpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw () __asm__ ("" "wcscpy")
+
+                                                ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wcscpy (wchar_t *__dest, __const wchar_t *__src) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcscpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcscpy_alias (__dest, __src);
+}
+
+
+extern wchar_t *__wcpcpy_chk (wchar_t *__dest, __const wchar_t *__src,
+         size_t __destlen) throw ();
+extern wchar_t *__wcpcpy_alias (wchar_t *__dest, __const wchar_t *__src) throw () __asm__ ("" "wcpcpy")
+
+           ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wcpcpy (wchar_t *__dest, __const wchar_t *__src) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcpcpy_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcpcpy_alias (__dest, __src);
+}
+
+
+extern wchar_t *__wcsncpy_chk (wchar_t *__restrict __dest,
+          __const wchar_t *__restrict __src, size_t __n,
+          size_t __destlen) throw ();
+extern wchar_t *__wcsncpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncpy")
+
+
+                          ;
+extern wchar_t *__wcsncpy_chk_warn (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcsncpy_chk")
+
+
+
+     __attribute__((__warning__ ("wcsncpy called with length bigger than size of destination " "buffer")))
+            ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wcsncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wcsncpy_chk (__dest, __src, __n,
+         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
+ return __wcsncpy_chk_warn (__dest, __src, __n,
+       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+    }
+  return __wcsncpy_alias (__dest, __src, __n);
+}
+
+
+extern wchar_t *__wcpncpy_chk (wchar_t *__restrict __dest,
+          __const wchar_t *__restrict __src, size_t __n,
+          size_t __destlen) throw ();
+extern wchar_t *__wcpncpy_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcpncpy")
+
+
+                          ;
+extern wchar_t *__wcpncpy_chk_warn (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n, size_t __destlen) throw () __asm__ ("" "__wcpncpy_chk")
+
+
+
+     __attribute__((__warning__ ("wcpncpy called with length bigger than size of destination " "buffer")))
+            ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wcpncpy (wchar_t *__dest, __const wchar_t *__src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n))
+ return __wcpncpy_chk (__dest, __src, __n,
+         __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+      if (__n > __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t))
+ return __wcpncpy_chk_warn (__dest, __src, __n,
+       __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+    }
+  return __wcpncpy_alias (__dest, __src, __n);
+}
+
+
+extern wchar_t *__wcscat_chk (wchar_t *__restrict __dest,
+         __const wchar_t *__restrict __src,
+         size_t __destlen) throw ();
+extern wchar_t *__wcscat_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src) throw () __asm__ ("" "wcscat")
+
+                                                ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wcscat (wchar_t *__dest, __const wchar_t *__src) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcscat_chk (__dest, __src, __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcscat_alias (__dest, __src);
+}
+
+
+extern wchar_t *__wcsncat_chk (wchar_t *__restrict __dest,
+          __const wchar_t *__restrict __src,
+          size_t __n, size_t __destlen) throw ();
+extern wchar_t *__wcsncat_alias (wchar_t *__restrict __dest, __const wchar_t *__restrict __src, size_t __n) throw () __asm__ ("" "wcsncat")
+
+
+                          ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) wchar_t *
+wcsncat (wchar_t *__dest, __const wchar_t *__src, size_t __n) throw ()
+{
+  if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1)
+    return __wcsncat_chk (__dest, __src, __n,
+     __builtin_object_size (__dest, 2 > 1) / sizeof (wchar_t));
+  return __wcsncat_alias (__dest, __src, __n);
+}
+
+
+extern int __swprintf_chk (wchar_t *__restrict __s, size_t __n,
+      int __flag, size_t __s_len,
+      __const wchar_t *__restrict __format, ...)
+     throw () ;
+
+extern int __swprintf_alias (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, ...) throw () __asm__ ("" "swprintf")
+
+
+             ;
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+swprintf (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, ...) throw ()
+
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
+    return __swprintf_chk (__s, __n, 2 - 1,
+      __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+      __fmt, __builtin_va_arg_pack ());
+  return __swprintf_alias (__s, __n, __fmt, __builtin_va_arg_pack ());
+}
+# 302 "/usr/include/bits/wchar2.h" 3 4
+extern int __vswprintf_chk (wchar_t *__restrict __s, size_t __n,
+       int __flag, size_t __s_len,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __arg)
+     throw () ;
+
+extern int __vswprintf_alias (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw () __asm__ ("" "vswprintf")
+
+
+                                     ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vswprintf (wchar_t *__restrict __s, size_t __n, __const wchar_t *__restrict __fmt, __gnuc_va_list __ap) throw ()
+
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 || 2 > 1)
+    return __vswprintf_chk (__s, __n, 2 - 1,
+       __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t), __fmt, __ap);
+  return __vswprintf_alias (__s, __n, __fmt, __ap);
+}
+
+
+
+
+extern int __fwprintf_chk (__FILE *__restrict __stream, int __flag,
+      __const wchar_t *__restrict __format, ...);
+extern int __wprintf_chk (int __flag, __const wchar_t *__restrict __format,
+     ...);
+extern int __vfwprintf_chk (__FILE *__restrict __stream, int __flag,
+       __const wchar_t *__restrict __format,
+       __gnuc_va_list __ap);
+extern int __vwprintf_chk (int __flag, __const wchar_t *__restrict __format,
+      __gnuc_va_list __ap);
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+wprintf (__const wchar_t *__restrict __fmt, ...)
+{
+  return __wprintf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+fwprintf (__FILE *__restrict __stream, __const wchar_t *__restrict __fmt, ...)
+{
+  return __fwprintf_chk (__stream, 2 - 1, __fmt,
+    __builtin_va_arg_pack ());
+}
+
+
+
+
+
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vwprintf (__const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vwprintf_chk (2 - 1, __fmt, __ap);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vfwprintf (__FILE *__restrict __stream,
+    __const wchar_t *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vfwprintf_chk (__stream, 2 - 1, __fmt, __ap);
+}
+
+
+
+extern wchar_t *__fgetws_chk (wchar_t *__restrict __s, size_t __size, int __n,
+         __FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws")
+
+                                              __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_chk")
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws called with bigger size than length " "of destination buffer")))
+                                 ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
+fgetws (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgetws_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+        __n, __stream);
+
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
+ return __fgetws_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+      __n, __stream);
+    }
+  return __fgetws_alias (__s, __n, __stream);
+}
+
+
+extern wchar_t *__fgetws_unlocked_chk (wchar_t *__restrict __s, size_t __size,
+           int __n, __FILE *__restrict __stream)
+  __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_unlocked_alias (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream) __asm__ ("" "fgetws_unlocked")
+
+
+  __attribute__ ((__warn_unused_result__));
+extern wchar_t *__fgetws_unlocked_chk_warn (wchar_t *__restrict __s, size_t __size, int __n, __FILE *__restrict __stream) __asm__ ("" "__fgetws_unlocked_chk")
+
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgetws_unlocked called with bigger size than length " "of destination buffer")))
+                                 ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) wchar_t *
+fgetws_unlocked (wchar_t *__restrict __s, int __n, __FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgetws_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+          __n, __stream);
+
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t))
+ return __fgetws_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1) / sizeof (wchar_t),
+        __n, __stream);
+    }
+  return __fgetws_unlocked_alias (__s, __n, __stream);
+}
+
+
+
+extern size_t __wcrtomb_chk (char *__s, wchar_t __wchar, mbstate_t *__p,
+     size_t __buflen) throw () __attribute__ ((__warn_unused_result__));
+extern size_t __wcrtomb_alias (char *__restrict __s, wchar_t __wchar, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcrtomb")
+
+                                                __attribute__ ((__warn_unused_result__));
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
+wcrtomb (char *__s, wchar_t __wchar, mbstate_t *__ps) throw ()
+{
+
+
+
+
+
+
+
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
+    return __wcrtomb_chk (__s, __wchar, __ps, __builtin_object_size (__s, 2 > 1));
+  return __wcrtomb_alias (__s, __wchar, __ps);
+}
+
+
+extern size_t __mbsrtowcs_chk (wchar_t *__restrict __dst,
+          __const char **__restrict __src,
+          size_t __len, mbstate_t *__restrict __ps,
+          size_t __dstlen) throw ();
+extern size_t __mbsrtowcs_alias (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsrtowcs")
+
+
+
+                   ;
+extern size_t __mbsrtowcs_chk_warn (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsrtowcs_chk")
+
+
+
+
+     __attribute__((__warning__ ("mbsrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
+                        ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+mbsrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
+
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __mbsrtowcs_chk (__dst, __src, __len, __ps,
+    __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+
+      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
+ return __mbsrtowcs_chk_warn (__dst, __src, __len, __ps,
+         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+    }
+  return __mbsrtowcs_alias (__dst, __src, __len, __ps);
+}
+
+
+extern size_t __wcsrtombs_chk (char *__restrict __dst,
+          __const wchar_t **__restrict __src,
+          size_t __len, mbstate_t *__restrict __ps,
+          size_t __dstlen) throw ();
+extern size_t __wcsrtombs_alias (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsrtombs")
+
+
+
+                   ;
+extern size_t __wcsrtombs_chk_warn (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsrtombs_chk")
+
+
+
+
+    __attribute__((__warning__ ("wcsrtombs called with dst buffer smaller than len")));
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+wcsrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __len, mbstate_t *__restrict __ps) throw ()
+
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __wcsrtombs_chk (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
+
+      if (__len > __builtin_object_size (__dst, 2 > 1))
+ return __wcsrtombs_chk_warn (__dst, __src, __len, __ps, __builtin_object_size (__dst, 2 > 1));
+    }
+  return __wcsrtombs_alias (__dst, __src, __len, __ps);
+}
+
+
+
+extern size_t __mbsnrtowcs_chk (wchar_t *__restrict __dst,
+    __const char **__restrict __src, size_t __nmc,
+    size_t __len, mbstate_t *__restrict __ps,
+    size_t __dstlen) throw ();
+extern size_t __mbsnrtowcs_alias (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "mbsnrtowcs")
+
+
+
+                    ;
+extern size_t __mbsnrtowcs_chk_warn (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__mbsnrtowcs_chk")
+
+
+
+
+     __attribute__((__warning__ ("mbsnrtowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
+                        ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+mbsnrtowcs (wchar_t *__restrict __dst, __const char **__restrict __src, size_t __nmc, size_t __len, mbstate_t *__restrict __ps) throw ()
+
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __mbsnrtowcs_chk (__dst, __src, __nmc, __len, __ps,
+     __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+
+      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
+ return __mbsnrtowcs_chk_warn (__dst, __src, __nmc, __len, __ps,
+          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+    }
+  return __mbsnrtowcs_alias (__dst, __src, __nmc, __len, __ps);
+}
+
+
+extern size_t __wcsnrtombs_chk (char *__restrict __dst,
+    __const wchar_t **__restrict __src,
+    size_t __nwc, size_t __len,
+    mbstate_t *__restrict __ps, size_t __dstlen)
+     throw ();
+extern size_t __wcsnrtombs_alias (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw () __asm__ ("" "wcsnrtombs")
+
+
+
+                                                  ;
+extern size_t __wcsnrtombs_chk_warn (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps, size_t __dstlen) throw () __asm__ ("" "__wcsnrtombs_chk")
+
+
+
+
+
+     __attribute__((__warning__ ("wcsnrtombs called with dst buffer smaller than len")));
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+wcsnrtombs (char *__restrict __dst, __const wchar_t **__restrict __src, size_t __nwc, size_t __len, mbstate_t *__restrict __ps) throw ()
+
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __wcsnrtombs_chk (__dst, __src, __nwc, __len, __ps,
+     __builtin_object_size (__dst, 2 > 1));
+
+      if (__len > __builtin_object_size (__dst, 2 > 1))
+ return __wcsnrtombs_chk_warn (__dst, __src, __nwc, __len, __ps,
+          __builtin_object_size (__dst, 2 > 1));
+    }
+  return __wcsnrtombs_alias (__dst, __src, __nwc, __len, __ps);
+}
+# 883 "/usr/include/wchar.h" 2 3 4
+
+
+
+
+
+
+}
+# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3
+# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::mbstate_t;
+
+}
+# 139 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::wint_t;
+
+  using ::btowc;
+  using ::fgetwc;
+  using ::fgetws;
+  using ::fputwc;
+  using ::fputws;
+  using ::fwide;
+  using ::fwprintf;
+  using ::fwscanf;
+  using ::getwc;
+  using ::getwchar;
+  using ::mbrlen;
+  using ::mbrtowc;
+  using ::mbsinit;
+  using ::mbsrtowcs;
+  using ::putwc;
+  using ::putwchar;
+
+  using ::swprintf;
+
+  using ::swscanf;
+  using ::ungetwc;
+  using ::vfwprintf;
+
+  using ::vfwscanf;
+
+
+  using ::vswprintf;
+
+
+  using ::vswscanf;
+
+  using ::vwprintf;
+
+  using ::vwscanf;
+
+  using ::wcrtomb;
+  using ::wcscat;
+  using ::wcscmp;
+  using ::wcscoll;
+  using ::wcscpy;
+  using ::wcscspn;
+  using ::wcsftime;
+  using ::wcslen;
+  using ::wcsncat;
+  using ::wcsncmp;
+  using ::wcsncpy;
+  using ::wcsrtombs;
+  using ::wcsspn;
+  using ::wcstod;
+
+  using ::wcstof;
+
+  using ::wcstok;
+  using ::wcstol;
+  using ::wcstoul;
+  using ::wcsxfrm;
+  using ::wctob;
+  using ::wmemcmp;
+  using ::wmemcpy;
+  using ::wmemmove;
+  using ::wmemset;
+  using ::wprintf;
+  using ::wscanf;
+  using ::wcschr;
+  using ::wcspbrk;
+  using ::wcsrchr;
+  using ::wcsstr;
+  using ::wmemchr;
+# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+}
+
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+
+  using ::wcstold;
+# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+  using ::wcstoll;
+  using ::wcstoull;
+
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::__gnu_cxx::wcstold;
+  using ::__gnu_cxx::wcstoll;
+  using ::__gnu_cxx::wcstoull;
+
+}
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 2 3
+# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 88 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+  typedef long streamoff;
+# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+  typedef ptrdiff_t streamsize;
+# 111 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+  template<typename _StateT>
+    class fpos
+    {
+    private:
+      streamoff _M_off;
+      _StateT _M_state;
+
+    public:
+
+
+
+
+      fpos()
+      : _M_off(0), _M_state() { }
+# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+      fpos(streamoff __off)
+      : _M_off(__off), _M_state() { }
+
+
+      operator streamoff() const { return _M_off; }
+
+
+      void
+      state(_StateT __st)
+      { _M_state = __st; }
+
+
+      _StateT
+      state() const
+      { return _M_state; }
+
+
+
+
+
+      fpos&
+      operator+=(streamoff __off)
+      {
+ _M_off += __off;
+ return *this;
+      }
+
+
+
+
+
+      fpos&
+      operator-=(streamoff __off)
+      {
+ _M_off -= __off;
+ return *this;
+      }
+
+
+
+
+
+
+
+      fpos
+      operator+(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos += __off;
+ return __pos;
+      }
+
+
+
+
+
+
+
+      fpos
+      operator-(streamoff __off) const
+      {
+ fpos __pos(*this);
+ __pos -= __off;
+ return __pos;
+      }
+
+
+
+
+
+
+      streamoff
+      operator-(const fpos& __other) const
+      { return _M_off - __other._M_off; }
+    };
+
+
+
+
+
+
+  template<typename _StateT>
+    inline bool
+    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) == streamoff(__rhs); }
+
+  template<typename _StateT>
+    inline bool
+    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
+    { return streamoff(__lhs) != streamoff(__rhs); }
+
+
+
+
+
+  typedef fpos<mbstate_t> streampos;
+
+  typedef fpos<mbstate_t> wstreampos;
+# 239 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/postypes.h" 3
+}
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwchar" 2 3
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 2 3
+# 52 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct _Char_types
+    {
+      typedef unsigned long int_type;
+      typedef std::streampos pos_type;
+      typedef std::streamoff off_type;
+      typedef std::mbstate_t state_type;
+    };
+# 89 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
+  template<typename _CharT>
+    struct char_traits
+    {
+      typedef _CharT char_type;
+      typedef typename _Char_types<_CharT>::int_type int_type;
+      typedef typename _Char_types<_CharT>::pos_type pos_type;
+      typedef typename _Char_types<_CharT>::off_type off_type;
+      typedef typename _Char_types<_CharT>::state_type state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static std::size_t
+      length(const char_type* __s);
+
+      static const char_type*
+      find(const char_type* __s, std::size_t __n, const char_type& __a);
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, std::size_t __n);
+
+      static char_type*
+      assign(char_type* __s, std::size_t __n, char_type __a);
+
+      static char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+
+      static int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(__c); }
+
+      static bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static int_type
+      eof()
+      { return static_cast<int_type>((-1)); }
+
+      static int_type
+      not_eof(const int_type& __c)
+      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }
+    };
+
+  template<typename _CharT>
+    int
+    char_traits<_CharT>::
+    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+ if (lt(__s1[__i], __s2[__i]))
+   return -1;
+ else if (lt(__s2[__i], __s1[__i]))
+   return 1;
+      return 0;
+    }
+
+  template<typename _CharT>
+    std::size_t
+    char_traits<_CharT>::
+    length(const char_type* __p)
+    {
+      std::size_t __i = 0;
+      while (!eq(__p[__i], char_type()))
+        ++__i;
+      return __i;
+    }
+
+  template<typename _CharT>
+    const typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    find(const char_type* __s, std::size_t __n, const char_type& __a)
+    {
+      for (std::size_t __i = 0; __i < __n; ++__i)
+        if (eq(__s[__i], __a))
+          return __s + __i;
+      return 0;
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    move(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+      return static_cast<_CharT*>(__builtin_memmove(__s1, __s2,
+          __n * sizeof(char_type)));
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
+    {
+
+      std::copy(__s2, __s2 + __n, __s1);
+      return __s1;
+    }
+
+  template<typename _CharT>
+    typename char_traits<_CharT>::char_type*
+    char_traits<_CharT>::
+    assign(char_type* __s, std::size_t __n, char_type __a)
+    {
+
+      std::fill_n(__s, __n, __a);
+      return __s;
+    }
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 230 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/char_traits.h" 3
+  template<class _CharT>
+    struct char_traits : public __gnu_cxx::char_traits<_CharT>
+    { };
+
+
+
+  template<>
+    struct char_traits<char>
+    {
+      typedef char char_type;
+      typedef int int_type;
+      typedef streampos pos_type;
+      typedef streamoff off_type;
+      typedef mbstate_t state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      { return __builtin_memcmp(__s1, __s2, __n); }
+
+      static size_t
+      length(const char_type* __s)
+      { return __builtin_strlen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); }
+
+      static char_type
+      to_char_type(const int_type& __c)
+      { return static_cast<char_type>(__c); }
+
+
+
+      static int_type
+      to_int_type(const char_type& __c)
+      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }
+
+      static bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static int_type
+      eof()
+      { return static_cast<int_type>((-1)); }
+
+      static int_type
+      not_eof(const int_type& __c)
+      { return (__c == eof()) ? 0 : __c; }
+  };
+
+
+
+
+  template<>
+    struct char_traits<wchar_t>
+    {
+      typedef wchar_t char_type;
+      typedef wint_t int_type;
+      typedef streamoff off_type;
+      typedef wstreampos pos_type;
+      typedef mbstate_t state_type;
+
+      static void
+      assign(char_type& __c1, const char_type& __c2)
+      { __c1 = __c2; }
+
+      static bool
+      eq(const char_type& __c1, const char_type& __c2)
+      { return __c1 == __c2; }
+
+      static bool
+      lt(const char_type& __c1, const char_type& __c2)
+      { return __c1 < __c2; }
+
+      static int
+      compare(const char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemcmp(__s1, __s2, __n); }
+
+      static size_t
+      length(const char_type* __s)
+      { return wcslen(__s); }
+
+      static const char_type*
+      find(const char_type* __s, size_t __n, const char_type& __a)
+      { return wmemchr(__s, __a, __n); }
+
+      static char_type*
+      move(char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemmove(__s1, __s2, __n); }
+
+      static char_type*
+      copy(char_type* __s1, const char_type* __s2, size_t __n)
+      { return wmemcpy(__s1, __s2, __n); }
+
+      static char_type*
+      assign(char_type* __s, size_t __n, char_type __a)
+      { return wmemset(__s, __a, __n); }
+
+      static char_type
+      to_char_type(const int_type& __c)
+      { return char_type(__c); }
+
+      static int_type
+      to_int_type(const char_type& __c)
+      { return int_type(__c); }
+
+      static bool
+      eq_int_type(const int_type& __c1, const int_type& __c2)
+      { return __c1 == __c2; }
+
+      static int_type
+      eof()
+      { return static_cast<int_type>((0xffffffffu)); }
+
+      static int_type
+      not_eof(const int_type& __c)
+      { return eq_int_type(__c, eof()) ? 0 : __c; }
+  };
+
+
+}
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 1 3
+# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 1 3
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
+       
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
+
+#pragma GCC visibility push(default)
+
+
+
+extern "C++" {
+
+namespace std
+{
+# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
+  class exception
+  {
+  public:
+    exception() throw() { }
+    virtual ~exception() throw();
+
+
+
+    virtual const char* what() const throw();
+  };
+
+
+
+  class bad_exception : public exception
+  {
+  public:
+    bad_exception() throw() { }
+
+
+
+    virtual ~bad_exception() throw();
+
+
+    virtual const char* what() const throw();
+  };
+
+
+  typedef void (*terminate_handler) ();
+
+
+  typedef void (*unexpected_handler) ();
+
+
+  terminate_handler set_terminate(terminate_handler) throw();
+
+
+
+  void terminate() throw() __attribute__ ((__noreturn__));
+
+
+  unexpected_handler set_unexpected(unexpected_handler) throw();
+
+
+
+  void unexpected() __attribute__ ((__noreturn__));
+# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
+  bool uncaught_exception() throw() __attribute__ ((__pure__));
+
+
+}
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+# 141 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/exception" 3
+  void __verbose_terminate_handler();
+
+}
+
+}
+
+#pragma GCC visibility pop
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 2 3
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace std
+{
+
+
+
+
+
+
+  class bad_alloc : public exception
+  {
+  public:
+    bad_alloc() throw() { }
+
+
+
+    virtual ~bad_alloc() throw();
+
+
+    virtual const char* what() const throw();
+  };
+
+  struct nothrow_t { };
+
+  extern const nothrow_t nothrow;
+
+
+
+  typedef void (*new_handler)();
+
+
+
+  new_handler set_new_handler(new_handler) throw();
+}
+# 93 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/new" 3
+void* operator new(std::size_t) throw (std::bad_alloc);
+void* operator new[](std::size_t) throw (std::bad_alloc);
+void operator delete(void*) throw();
+void operator delete[](void*) throw();
+void* operator new(std::size_t, const std::nothrow_t&) throw();
+void* operator new[](std::size_t, const std::nothrow_t&) throw();
+void operator delete(void*, const std::nothrow_t&) throw();
+void operator delete[](void*, const std::nothrow_t&) throw();
+
+
+inline void* operator new(std::size_t, void* __p) throw() { return __p; }
+inline void* operator new[](std::size_t, void* __p) throw() { return __p; }
+
+
+inline void operator delete (void*, void*) throw() { }
+inline void operator delete[](void*, void*) throw() { }
+
+}
+
+#pragma GCC visibility pop
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 2 3
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+  using std::size_t;
+  using std::ptrdiff_t;
+# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 3
+  template<typename _Tp>
+    class new_allocator
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef new_allocator<_Tp1> other; };
+
+      new_allocator() throw() { }
+
+      new_allocator(const new_allocator&) throw() { }
+
+      template<typename _Tp1>
+        new_allocator(const new_allocator<_Tp1>&) throw() { }
+
+      ~new_allocator() throw() { }
+
+      pointer
+      address(reference __x) const { return &__x; }
+
+      const_pointer
+      address(const_reference __x) const { return &__x; }
+
+
+
+      pointer
+      allocate(size_type __n, const void* = 0)
+      {
+ if (__n > this->max_size())
+   std::__throw_bad_alloc();
+
+ return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
+      }
+
+
+      void
+      deallocate(pointer __p, size_type)
+      { ::operator delete(__p); }
+
+      size_type
+      max_size() const throw()
+      { return size_t(-1) / sizeof(_Tp); }
+
+
+
+      void
+      construct(pointer __p, const _Tp& __val)
+      { ::new((void *)__p) _Tp(__val); }
+# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/new_allocator.h" 3
+      void
+      destroy(pointer __p) { __p->~_Tp(); }
+    };
+
+  template<typename _Tp>
+    inline bool
+    operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return true; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&)
+    { return false; }
+
+}
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3
+# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
+  template<typename _Tp>
+    class allocator;
+
+
+  template<>
+    class allocator<void>
+    {
+    public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef void* pointer;
+      typedef const void* const_pointer;
+      typedef void value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+    };
+# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
+  template<typename _Tp>
+    class allocator: public __gnu_cxx::new_allocator<_Tp>
+    {
+   public:
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Tp* pointer;
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      typedef const _Tp& const_reference;
+      typedef _Tp value_type;
+
+      template<typename _Tp1>
+        struct rebind
+        { typedef allocator<_Tp1> other; };
+
+      allocator() throw() { }
+
+      allocator(const allocator& __a) throw()
+      : __gnu_cxx::new_allocator<_Tp>(__a) { }
+
+      template<typename _Tp1>
+        allocator(const allocator<_Tp1>&) throw() { }
+
+      ~allocator() throw() { }
+
+
+    };
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator==(const allocator<_T1>&, const allocator<_T2>&)
+    { return true; }
+
+  template<typename _Tp>
+    inline bool
+    operator==(const allocator<_Tp>&, const allocator<_Tp>&)
+    { return true; }
+
+  template<typename _T1, typename _T2>
+    inline bool
+    operator!=(const allocator<_T1>&, const allocator<_T2>&)
+    { return false; }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const allocator<_Tp>&, const allocator<_Tp>&)
+    { return false; }
+
+
+
+
+
+  extern template class allocator<char>;
+  extern template class allocator<wchar_t>;
+
+
+
+
+
+
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_swap
+    { static void _S_do_it(_Alloc&, _Alloc&) { } };
+
+  template<typename _Alloc>
+    struct __alloc_swap<_Alloc, false>
+    {
+      static void
+      _S_do_it(_Alloc& __one, _Alloc& __two)
+      {
+
+ if (__one != __two)
+   swap(__one, __two);
+      }
+    };
+
+
+  template<typename _Alloc, bool = __is_empty(_Alloc)>
+    struct __alloc_neq
+    {
+      static bool
+      _S_do_it(const _Alloc&, const _Alloc&)
+      { return false; }
+    };
+
+  template<typename _Alloc>
+    struct __alloc_neq<_Alloc, false>
+    {
+      static bool
+      _S_do_it(const _Alloc& __one, const _Alloc& __two)
+      { return __one != __two; }
+    };
+# 204 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/allocator.h" 3
+}
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+       
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 3
+
+
+# 1 "/usr/include/locale.h" 1 3 4
+# 29 "/usr/include/locale.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 30 "/usr/include/locale.h" 2 3 4
+# 1 "/usr/include/bits/locale.h" 1 3 4
+# 27 "/usr/include/bits/locale.h" 3 4
+enum
+{
+  __LC_CTYPE = 0,
+  __LC_NUMERIC = 1,
+  __LC_TIME = 2,
+  __LC_COLLATE = 3,
+  __LC_MONETARY = 4,
+  __LC_MESSAGES = 5,
+  __LC_ALL = 6,
+  __LC_PAPER = 7,
+  __LC_NAME = 8,
+  __LC_ADDRESS = 9,
+  __LC_TELEPHONE = 10,
+  __LC_MEASUREMENT = 11,
+  __LC_IDENTIFICATION = 12
+};
+# 31 "/usr/include/locale.h" 2 3 4
+
+extern "C" {
+# 51 "/usr/include/locale.h" 3 4
+
+
+
+struct lconv
+{
+
+
+  char *decimal_point;
+  char *thousands_sep;
+
+
+
+
+
+  char *grouping;
+
+
+
+
+
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+
+  char p_cs_precedes;
+
+  char p_sep_by_space;
+
+  char n_cs_precedes;
+
+  char n_sep_by_space;
+
+
+
+
+
+
+  char p_sign_posn;
+  char n_sign_posn;
+
+
+  char int_p_cs_precedes;
+
+  char int_p_sep_by_space;
+
+  char int_n_cs_precedes;
+
+  char int_n_sep_by_space;
+
+
+
+
+
+
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+# 121 "/usr/include/locale.h" 3 4
+};
+
+
+
+extern char *setlocale (int __category, __const char *__locale) throw ();
+
+
+extern struct lconv *localeconv (void) throw ();
+
+
+# 152 "/usr/include/locale.h" 3 4
+extern __locale_t newlocale (int __category_mask, __const char *__locale,
+        __locale_t __base) throw ();
+# 187 "/usr/include/locale.h" 3 4
+extern __locale_t duplocale (__locale_t __dataset) throw ();
+
+
+
+extern void freelocale (__locale_t __dataset) throw ();
+
+
+
+
+
+
+extern __locale_t uselocale (__locale_t __dataset) throw ();
+
+
+
+
+
+
+
+}
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 2 3
+# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/clocale" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::lconv;
+  using ::setlocale;
+  using ::localeconv;
+
+}
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3
+
+
+
+
+
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+  extern "C" __typeof(uselocale) __uselocale;
+
+}
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  typedef __locale_t __c_locale;
+
+
+
+
+
+  inline int
+  __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)),
+     char* __out,
+     const int __size __attribute__ ((__unused__)),
+     const char* __fmt, ...)
+  {
+
+    __c_locale __old = __gnu_cxx::__uselocale(__cloc);
+# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/c++locale.h" 3
+    __builtin_va_list __args;
+    __builtin_va_start(__args, __fmt);
+
+
+    const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args);
+
+
+
+
+    __builtin_va_end(__args);
+
+
+    __gnu_cxx::__uselocale(__old);
+
+
+
+
+
+
+
+    return __ret;
+  }
+
+}
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 3
+       
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iosfwd" 3
+  class ios_base;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ios;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_streambuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_istream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_iostream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+     typename _Alloc = allocator<_CharT> >
+    class basic_stringbuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_istringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_ostringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT>,
+    typename _Alloc = allocator<_CharT> >
+    class basic_stringstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_filebuf;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ifstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_ofstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class basic_fstream;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class istreambuf_iterator;
+
+  template<typename _CharT, typename _Traits = char_traits<_CharT> >
+    class ostreambuf_iterator;
+
+
+
+
+  typedef basic_ios<char> ios;
+  typedef basic_streambuf<char> streambuf;
+  typedef basic_istream<char> istream;
+  typedef basic_ostream<char> ostream;
+  typedef basic_iostream<char> iostream;
+  typedef basic_stringbuf<char> stringbuf;
+  typedef basic_istringstream<char> istringstream;
+  typedef basic_ostringstream<char> ostringstream;
+  typedef basic_stringstream<char> stringstream;
+  typedef basic_filebuf<char> filebuf;
+  typedef basic_ifstream<char> ifstream;
+  typedef basic_ofstream<char> ofstream;
+  typedef basic_fstream<char> fstream;
+
+
+  typedef basic_ios<wchar_t> wios;
+  typedef basic_streambuf<wchar_t> wstreambuf;
+  typedef basic_istream<wchar_t> wistream;
+  typedef basic_ostream<wchar_t> wostream;
+  typedef basic_iostream<wchar_t> wiostream;
+  typedef basic_stringbuf<wchar_t> wstringbuf;
+  typedef basic_istringstream<wchar_t> wistringstream;
+  typedef basic_ostringstream<wchar_t> wostringstream;
+  typedef basic_stringstream<wchar_t> wstringstream;
+  typedef basic_filebuf<wchar_t> wfilebuf;
+  typedef basic_ifstream<wchar_t> wifstream;
+  typedef basic_ofstream<wchar_t> wofstream;
+  typedef basic_fstream<wchar_t> wfstream;
+
+
+
+}
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
+
+
+# 1 "/usr/include/ctype.h" 1 3 4
+# 28 "/usr/include/ctype.h" 3 4
+# 1 "/usr/include/bits/types.h" 1 3 4
+# 28 "/usr/include/bits/types.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 29 "/usr/include/bits/types.h" 2 3 4
+
+
+typedef unsigned char __u_char;
+typedef unsigned short int __u_short;
+typedef unsigned int __u_int;
+typedef unsigned long int __u_long;
+
+
+typedef signed char __int8_t;
+typedef unsigned char __uint8_t;
+typedef signed short int __int16_t;
+typedef unsigned short int __uint16_t;
+typedef signed int __int32_t;
+typedef unsigned int __uint32_t;
+
+typedef signed long int __int64_t;
+typedef unsigned long int __uint64_t;
+
+
+
+
+
+
+
+typedef long int __quad_t;
+typedef unsigned long int __u_quad_t;
+# 131 "/usr/include/bits/types.h" 3 4
+# 1 "/usr/include/bits/typesizes.h" 1 3 4
+# 132 "/usr/include/bits/types.h" 2 3 4
+
+
+typedef unsigned long int __dev_t;
+typedef unsigned int __uid_t;
+typedef unsigned int __gid_t;
+typedef unsigned long int __ino_t;
+typedef unsigned long int __ino64_t;
+typedef unsigned int __mode_t;
+typedef unsigned long int __nlink_t;
+typedef long int __off_t;
+typedef long int __off64_t;
+typedef int __pid_t;
+typedef struct { int __val[2]; } __fsid_t;
+typedef long int __clock_t;
+typedef unsigned long int __rlim_t;
+typedef unsigned long int __rlim64_t;
+typedef unsigned int __id_t;
+typedef long int __time_t;
+typedef unsigned int __useconds_t;
+typedef long int __suseconds_t;
+
+typedef int __daddr_t;
+typedef long int __swblk_t;
+typedef int __key_t;
+
+
+typedef int __clockid_t;
+
+
+typedef void * __timer_t;
+
+
+typedef long int __blksize_t;
+
+
+
+
+typedef long int __blkcnt_t;
+typedef long int __blkcnt64_t;
+
+
+typedef unsigned long int __fsblkcnt_t;
+typedef unsigned long int __fsblkcnt64_t;
+
+
+typedef unsigned long int __fsfilcnt_t;
+typedef unsigned long int __fsfilcnt64_t;
+
+typedef long int __ssize_t;
+
+
+
+typedef __off64_t __loff_t;
+typedef __quad_t *__qaddr_t;
+typedef char *__caddr_t;
+
+
+typedef long int __intptr_t;
+
+
+typedef unsigned int __socklen_t;
+# 29 "/usr/include/ctype.h" 2 3 4
+
+extern "C" {
+# 41 "/usr/include/ctype.h" 3 4
+# 1 "/usr/include/endian.h" 1 3 4
+# 37 "/usr/include/endian.h" 3 4
+# 1 "/usr/include/bits/endian.h" 1 3 4
+# 38 "/usr/include/endian.h" 2 3 4
+# 61 "/usr/include/endian.h" 3 4
+# 1 "/usr/include/bits/byteswap.h" 1 3 4
+# 28 "/usr/include/bits/byteswap.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 29 "/usr/include/bits/byteswap.h" 2 3 4
+# 62 "/usr/include/endian.h" 2 3 4
+# 42 "/usr/include/ctype.h" 2 3 4
+
+
+
+
+
+
+enum
+{
+  _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
+  _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
+  _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
+  _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
+  _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
+  _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
+  _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
+  _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
+  _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
+  _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
+  _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
+  _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
+};
+# 81 "/usr/include/ctype.h" 3 4
+extern __const unsigned short int **__ctype_b_loc (void)
+     throw () __attribute__ ((__const));
+extern __const __int32_t **__ctype_tolower_loc (void)
+     throw () __attribute__ ((__const));
+extern __const __int32_t **__ctype_toupper_loc (void)
+     throw () __attribute__ ((__const));
+# 96 "/usr/include/ctype.h" 3 4
+
+
+
+
+
+
+extern int isalnum (int) throw ();
+extern int isalpha (int) throw ();
+extern int iscntrl (int) throw ();
+extern int isdigit (int) throw ();
+extern int islower (int) throw ();
+extern int isgraph (int) throw ();
+extern int isprint (int) throw ();
+extern int ispunct (int) throw ();
+extern int isspace (int) throw ();
+extern int isupper (int) throw ();
+extern int isxdigit (int) throw ();
+
+
+
+extern int tolower (int __c) throw ();
+
+
+extern int toupper (int __c) throw ();
+
+
+
+
+
+
+
+
+extern int isblank (int) throw ();
+
+
+
+
+
+
+extern int isctype (int __c, int __mask) throw ();
+
+
+
+
+
+
+extern int isascii (int __c) throw ();
+
+
+
+extern int toascii (int __c) throw ();
+
+
+
+extern int _toupper (int) throw ();
+extern int _tolower (int) throw ();
+# 247 "/usr/include/ctype.h" 3 4
+extern int isalnum_l (int, __locale_t) throw ();
+extern int isalpha_l (int, __locale_t) throw ();
+extern int iscntrl_l (int, __locale_t) throw ();
+extern int isdigit_l (int, __locale_t) throw ();
+extern int islower_l (int, __locale_t) throw ();
+extern int isgraph_l (int, __locale_t) throw ();
+extern int isprint_l (int, __locale_t) throw ();
+extern int ispunct_l (int, __locale_t) throw ();
+extern int isspace_l (int, __locale_t) throw ();
+extern int isupper_l (int, __locale_t) throw ();
+extern int isxdigit_l (int, __locale_t) throw ();
+
+extern int isblank_l (int, __locale_t) throw ();
+
+
+
+extern int __tolower_l (int __c, __locale_t __l) throw ();
+extern int tolower_l (int __c, __locale_t __l) throw ();
+
+
+extern int __toupper_l (int __c, __locale_t __l) throw ();
+extern int toupper_l (int __c, __locale_t __l) throw ();
+# 323 "/usr/include/ctype.h" 3 4
+}
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 2 3
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::isalnum;
+  using ::isalpha;
+  using ::iscntrl;
+  using ::isdigit;
+  using ::isgraph;
+  using ::islower;
+  using ::isprint;
+  using ::ispunct;
+  using ::isspace;
+  using ::isupper;
+  using ::isxdigit;
+  using ::tolower;
+  using ::toupper;
+
+}
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 55 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/localefwd.h" 3
+  class locale;
+
+  template<typename _Facet>
+    bool
+    has_facet(const locale&) throw();
+
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale&);
+
+
+  template<typename _CharT>
+    bool
+    isspace(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isprint(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    iscntrl(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    islower(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalpha(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    ispunct(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isxdigit(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isalnum(_CharT, const locale&);
+
+  template<typename _CharT>
+    bool
+    isgraph(_CharT, const locale&);
+
+  template<typename _CharT>
+    _CharT
+    toupper(_CharT, const locale&);
+
+  template<typename _CharT>
+    _CharT
+    tolower(_CharT, const locale&);
+
+
+  class ctype_base;
+  template<typename _CharT>
+    class ctype;
+  template<> class ctype<char>;
+
+  template<> class ctype<wchar_t>;
+
+  template<typename _CharT>
+    class ctype_byname;
+
+
+  class codecvt_base;
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt;
+  template<> class codecvt<char, char, mbstate_t>;
+
+  template<> class codecvt<wchar_t, char, mbstate_t>;
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname;
+
+
+
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class num_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class num_put;
+
+  template<typename _CharT> class numpunct;
+  template<typename _CharT> class numpunct_byname;
+
+
+  template<typename _CharT>
+    class collate;
+  template<typename _CharT> class
+    collate_byname;
+
+
+  class time_base;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get;
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class time_get_byname;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class time_put_byname;
+
+
+  class money_base;
+
+  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
+    class money_get;
+  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
+    class money_put;
+
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct;
+  template<typename _CharT, bool _Intl = false>
+    class moneypunct_byname;
+
+
+  class messages_base;
+  template<typename _CharT>
+    class messages;
+  template<typename _CharT>
+    class messages_byname;
+
+}
+# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 3
+       
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cxxabi-forced.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cxxabi-forced.h" 3
+       
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cxxabi-forced.h" 3
+
+#pragma GCC visibility push(default)
+
+
+namespace __cxxabiv1
+{
+
+
+
+
+
+
+
+  class __forced_unwind
+  {
+    virtual ~__forced_unwind() throw();
+
+
+    virtual void __pure_dummy() = 0;
+  };
+}
+
+
+#pragma GCC visibility pop
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream_insert.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+      const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+      if (__put != __n)
+ __out.setstate(__ios_base::badbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline void
+    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      const _CharT __c = __out.fill();
+      for (; __n > 0; --__n)
+ {
+   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+   if (_Traits::eq_int_type(__put, _Traits::eof()))
+     {
+       __out.setstate(__ios_base::badbit);
+       break;
+     }
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+       const _CharT* __s, streamsize __n)
+    {
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef typename __ostream_type::ios_base __ios_base;
+
+      typename __ostream_type::sentry __cerb(__out);
+      if (__cerb)
+ {
+   try
+     {
+       const streamsize __w = __out.width();
+       if (__w > __n)
+  {
+    const bool __left = ((__out.flags()
+     & __ios_base::adjustfield)
+           == __ios_base::left);
+    if (!__left)
+      __ostream_fill(__out, __w - __n);
+    if (__out.good())
+      __ostream_write(__out, __s, __n);
+    if (__left && __out.good())
+      __ostream_fill(__out, __w - __n);
+  }
+       else
+  __ostream_write(__out, __s, __n);
+       __out.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(__ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+
+  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);
+
+
+  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
+          streamsize);
+
+
+
+}
+# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 99 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+  template<typename _Arg, typename _Result>
+    struct unary_function
+    {
+      typedef _Arg argument_type;
+
+
+      typedef _Result result_type;
+    };
+
+
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    struct binary_function
+    {
+      typedef _Arg1 first_argument_type;
+
+
+      typedef _Arg2 second_argument_type;
+      typedef _Result result_type;
+    };
+# 134 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+  template<typename _Tp>
+    struct plus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x + __y; }
+    };
+
+
+  template<typename _Tp>
+    struct minus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x - __y; }
+    };
+
+
+  template<typename _Tp>
+    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x * __y; }
+    };
+
+
+  template<typename _Tp>
+    struct divides : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x / __y; }
+    };
+
+
+  template<typename _Tp>
+    struct modulus : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x % __y; }
+    };
+
+
+  template<typename _Tp>
+    struct negate : public unary_function<_Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x) const
+      { return -__x; }
+    };
+# 198 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+  template<typename _Tp>
+    struct equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x == __y; }
+    };
+
+
+  template<typename _Tp>
+    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x != __y; }
+    };
+
+
+  template<typename _Tp>
+    struct greater : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x > __y; }
+    };
+
+
+  template<typename _Tp>
+    struct less : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x < __y; }
+    };
+
+
+  template<typename _Tp>
+    struct greater_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x >= __y; }
+    };
+
+
+  template<typename _Tp>
+    struct less_equal : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x <= __y; }
+    };
+# 262 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+  template<typename _Tp>
+    struct logical_and : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x && __y; }
+    };
+
+
+  template<typename _Tp>
+    struct logical_or : public binary_function<_Tp, _Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x || __y; }
+    };
+
+
+  template<typename _Tp>
+    struct logical_not : public unary_function<_Tp, bool>
+    {
+      bool
+      operator()(const _Tp& __x) const
+      { return !__x; }
+    };
+
+
+
+
+  template<typename _Tp>
+    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x & __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x | __y; }
+    };
+
+  template<typename _Tp>
+    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
+    {
+      _Tp
+      operator()(const _Tp& __x, const _Tp& __y) const
+      { return __x ^ __y; }
+    };
+# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+  template<typename _Predicate>
+    class unary_negate
+    : public unary_function<typename _Predicate::argument_type, bool>
+    {
+    public:
+      _Predicate _M_pred;
+
+    public:
+      explicit
+      unary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      bool
+      operator()(const typename _Predicate::argument_type& __x) const
+      { return !_M_pred(__x); }
+    };
+
+
+  template<typename _Predicate>
+    inline unary_negate<_Predicate>
+    not1(const _Predicate& __pred)
+    { return unary_negate<_Predicate>(__pred); }
+
+
+  template<typename _Predicate>
+    class binary_negate
+    : public binary_function<typename _Predicate::first_argument_type,
+        typename _Predicate::second_argument_type, bool>
+    {
+    public:
+      _Predicate _M_pred;
+
+    public:
+      explicit
+      binary_negate(const _Predicate& __x) : _M_pred(__x) { }
+
+      bool
+      operator()(const typename _Predicate::first_argument_type& __x,
+   const typename _Predicate::second_argument_type& __y) const
+      { return !_M_pred(__x, __y); }
+    };
+
+
+  template<typename _Predicate>
+    inline binary_negate<_Predicate>
+    not2(const _Predicate& __pred)
+    { return binary_negate<_Predicate>(__pred); }
+# 416 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+  template<typename _Arg, typename _Result>
+    class pointer_to_unary_function : public unary_function<_Arg, _Result>
+    {
+    public:
+      _Result (*_M_ptr)(_Arg);
+
+    public:
+      pointer_to_unary_function() { }
+
+      explicit
+      pointer_to_unary_function(_Result (*__x)(_Arg))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg __x) const
+      { return _M_ptr(__x); }
+    };
+
+
+  template<typename _Arg, typename _Result>
+    inline pointer_to_unary_function<_Arg, _Result>
+    ptr_fun(_Result (*__x)(_Arg))
+    { return pointer_to_unary_function<_Arg, _Result>(__x); }
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    class pointer_to_binary_function
+    : public binary_function<_Arg1, _Arg2, _Result>
+    {
+    public:
+      _Result (*_M_ptr)(_Arg1, _Arg2);
+
+    public:
+      pointer_to_binary_function() { }
+
+      explicit
+      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
+      : _M_ptr(__x) { }
+
+      _Result
+      operator()(_Arg1 __x, _Arg2 __y) const
+      { return _M_ptr(__x, __y); }
+    };
+
+
+  template<typename _Arg1, typename _Arg2, typename _Result>
+    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
+    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
+    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
+
+
+  template<typename _Tp>
+    struct _Identity : public unary_function<_Tp,_Tp>
+    {
+      _Tp&
+      operator()(_Tp& __x) const
+      { return __x; }
+
+      const _Tp&
+      operator()(const _Tp& __x) const
+      { return __x; }
+    };
+
+  template<typename _Pair>
+    struct _Select1st : public unary_function<_Pair,
+           typename _Pair::first_type>
+    {
+      typename _Pair::first_type&
+      operator()(_Pair& __x) const
+      { return __x.first; }
+
+      const typename _Pair::first_type&
+      operator()(const _Pair& __x) const
+      { return __x.first; }
+    };
+
+  template<typename _Pair>
+    struct _Select2nd : public unary_function<_Pair,
+           typename _Pair::second_type>
+    {
+      typename _Pair::second_type&
+      operator()(_Pair& __x) const
+      { return __x.second; }
+
+      const typename _Pair::second_type&
+      operator()(const _Pair& __x) const
+      { return __x.second; }
+    };
+# 523 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 3
+  template<typename _Ret, typename _Tp>
+    class mem_fun_t : public unary_function<_Tp*, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p) const
+      { return (__p->*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      mem_fun_ref_t(_Ret (_Tp::*__pf)())
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)();
+  };
+
+
+
+  template<typename _Ret, typename _Tp>
+    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r) const
+      { return (__r.*_M_f)(); }
+
+    private:
+      _Ret (_Tp::*_M_f)() const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp* __p, _Arg __x) const
+      { return (__p->*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(_Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg);
+    };
+
+
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
+    {
+    public:
+      explicit
+      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
+      : _M_f(__pf) { }
+
+      _Ret
+      operator()(const _Tp& __r, _Arg __x) const
+      { return (__r.*_M_f)(__x); }
+
+    private:
+      _Ret (_Tp::*_M_f)(_Arg) const;
+    };
+
+
+
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)())
+    { return mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_t<_Ret, _Tp>
+    mem_fun(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)())
+    { return mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp>
+    inline const_mem_fun_ref_t<_Ret, _Tp>
+    mem_fun_ref(_Ret (_Tp::*__f)() const)
+    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
+    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
+    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+  template<typename _Ret, typename _Tp, typename _Arg>
+    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
+    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
+    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
+
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/binders.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/binders.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 97 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/binders.h" 3
+  template<typename _Operation>
+    class binder1st
+    : public unary_function<typename _Operation::second_argument_type,
+       typename _Operation::result_type>
+    {
+    public:
+      _Operation op;
+      typename _Operation::first_argument_type value;
+
+    public:
+      binder1st(const _Operation& __x,
+  const typename _Operation::first_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+
+
+
+      typename _Operation::result_type
+      operator()(typename _Operation::second_argument_type& __x) const
+      { return op(value, __x); }
+    } ;
+
+
+  template<typename _Operation, typename _Tp>
+    inline binder1st<_Operation>
+    bind1st(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::first_argument_type _Arg1_type;
+      return binder1st<_Operation>(__fn, _Arg1_type(__x));
+    }
+
+
+  template<typename _Operation>
+    class binder2nd
+    : public unary_function<typename _Operation::first_argument_type,
+       typename _Operation::result_type>
+    {
+    public:
+      _Operation op;
+      typename _Operation::second_argument_type value;
+
+    public:
+      binder2nd(const _Operation& __x,
+  const typename _Operation::second_argument_type& __y)
+      : op(__x), value(__y) { }
+
+      typename _Operation::result_type
+      operator()(const typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+
+
+
+      typename _Operation::result_type
+      operator()(typename _Operation::first_argument_type& __x) const
+      { return op(__x, value); }
+    } ;
+
+
+  template<typename _Operation, typename _Tp>
+    inline binder2nd<_Operation>
+    bind2nd(const _Operation& __fn, const _Tp& __x)
+    {
+      typedef typename _Operation::second_argument_type _Arg2_type;
+      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
+    }
+
+
+}
+# 713 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_function.h" 2 3
+# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 1 3
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 1 3
+# 30 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 3
+#pragma GCC visibility push(default)
+# 162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+# 1 "/usr/include/pthread.h" 1 3 4
+# 25 "/usr/include/pthread.h" 3 4
+# 1 "/usr/include/sched.h" 1 3 4
+# 29 "/usr/include/sched.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 30 "/usr/include/sched.h" 2 3 4
+
+
+# 1 "/usr/include/time.h" 1 3 4
+# 120 "/usr/include/time.h" 3 4
+struct timespec
+  {
+    __time_t tv_sec;
+    long int tv_nsec;
+  };
+# 33 "/usr/include/sched.h" 2 3 4
+
+
+# 1 "/usr/include/bits/sched.h" 1 3 4
+# 71 "/usr/include/bits/sched.h" 3 4
+struct sched_param
+  {
+    int __sched_priority;
+  };
+
+extern "C" {
+
+
+
+extern int clone (int (*__fn) (void *__arg), void *__child_stack,
+    int __flags, void *__arg, ...) throw ();
+
+
+extern int unshare (int __flags) throw ();
+
+
+extern int sched_getcpu (void) throw ();
+
+
+}
+
+
+
+
+
+
+
+struct __sched_param
+  {
+    int __sched_priority;
+  };
+# 113 "/usr/include/bits/sched.h" 3 4
+typedef unsigned long int __cpu_mask;
+
+
+
+
+
+
+typedef struct
+{
+  __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))];
+} cpu_set_t;
+# 196 "/usr/include/bits/sched.h" 3 4
+extern "C" {
+
+extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
+  throw ();
+extern cpu_set_t *__sched_cpualloc (size_t __count) throw () __attribute__ ((__warn_unused_result__));
+extern void __sched_cpufree (cpu_set_t *__set) throw ();
+
+}
+# 36 "/usr/include/sched.h" 2 3 4
+
+
+
+
+extern "C" {
+
+
+extern int sched_setparam (__pid_t __pid, __const struct sched_param *__param)
+     throw ();
+
+
+extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw ();
+
+
+extern int sched_setscheduler (__pid_t __pid, int __policy,
+          __const struct sched_param *__param) throw ();
+
+
+extern int sched_getscheduler (__pid_t __pid) throw ();
+
+
+extern int sched_yield (void) throw ();
+
+
+extern int sched_get_priority_max (int __algorithm) throw ();
+
+
+extern int sched_get_priority_min (int __algorithm) throw ();
+
+
+extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw ();
+# 110 "/usr/include/sched.h" 3 4
+extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
+         __const cpu_set_t *__cpuset) throw ();
+
+
+extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
+         cpu_set_t *__cpuset) throw ();
+
+
+}
+# 26 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/time.h" 1 3 4
+# 30 "/usr/include/time.h" 3 4
+extern "C" {
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 39 "/usr/include/time.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/time.h" 1 3 4
+# 43 "/usr/include/time.h" 2 3 4
+# 58 "/usr/include/time.h" 3 4
+
+
+typedef __clock_t clock_t;
+
+
+
+# 74 "/usr/include/time.h" 3 4
+
+
+typedef __time_t time_t;
+
+
+
+# 92 "/usr/include/time.h" 3 4
+typedef __clockid_t clockid_t;
+# 104 "/usr/include/time.h" 3 4
+typedef __timer_t timer_t;
+# 131 "/usr/include/time.h" 3 4
+
+
+struct tm
+{
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+
+
+  long int tm_gmtoff;
+  __const char *tm_zone;
+
+
+
+
+};
+
+
+
+
+
+
+
+
+struct itimerspec
+  {
+    struct timespec it_interval;
+    struct timespec it_value;
+  };
+
+
+struct sigevent;
+
+
+
+
+
+typedef __pid_t pid_t;
+
+
+
+
+
+
+
+
+extern clock_t clock (void) throw ();
+
+
+extern time_t time (time_t *__timer) throw ();
+
+
+extern double difftime (time_t __time1, time_t __time0)
+     throw () __attribute__ ((__const__));
+
+
+extern time_t mktime (struct tm *__tp) throw ();
+
+
+
+
+
+extern size_t strftime (char *__restrict __s, size_t __maxsize,
+   __const char *__restrict __format,
+   __const struct tm *__restrict __tp) throw ();
+
+
+
+
+
+extern char *strptime (__const char *__restrict __s,
+         __const char *__restrict __fmt, struct tm *__tp)
+     throw ();
+
+
+
+
+
+
+
+extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
+     __const char *__restrict __format,
+     __const struct tm *__restrict __tp,
+     __locale_t __loc) throw ();
+
+
+
+extern char *strptime_l (__const char *__restrict __s,
+    __const char *__restrict __fmt, struct tm *__tp,
+    __locale_t __loc) throw ();
+
+
+
+
+
+
+extern struct tm *gmtime (__const time_t *__timer) throw ();
+
+
+
+extern struct tm *localtime (__const time_t *__timer) throw ();
+
+
+
+
+
+extern struct tm *gmtime_r (__const time_t *__restrict __timer,
+       struct tm *__restrict __tp) throw ();
+
+
+
+extern struct tm *localtime_r (__const time_t *__restrict __timer,
+          struct tm *__restrict __tp) throw ();
+
+
+
+
+
+extern char *asctime (__const struct tm *__tp) throw ();
+
+
+extern char *ctime (__const time_t *__timer) throw ();
+
+
+
+
+
+
+
+extern char *asctime_r (__const struct tm *__restrict __tp,
+   char *__restrict __buf) throw ();
+
+
+extern char *ctime_r (__const time_t *__restrict __timer,
+        char *__restrict __buf) throw ();
+
+
+
+
+extern char *__tzname[2];
+extern int __daylight;
+extern long int __timezone;
+
+
+
+
+extern char *tzname[2];
+
+
+
+extern void tzset (void) throw ();
+
+
+
+extern int daylight;
+extern long int timezone;
+
+
+
+
+
+extern int stime (__const time_t *__when) throw ();
+# 313 "/usr/include/time.h" 3 4
+extern time_t timegm (struct tm *__tp) throw ();
+
+
+extern time_t timelocal (struct tm *__tp) throw ();
+
+
+extern int dysize (int __year) throw () __attribute__ ((__const__));
+# 328 "/usr/include/time.h" 3 4
+extern int nanosleep (__const struct timespec *__requested_time,
+        struct timespec *__remaining);
+
+
+
+extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw ();
+
+
+extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw ();
+
+
+extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp)
+     throw ();
+
+
+
+
+
+
+extern int clock_nanosleep (clockid_t __clock_id, int __flags,
+       __const struct timespec *__req,
+       struct timespec *__rem);
+
+
+extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) throw ();
+
+
+
+
+extern int timer_create (clockid_t __clock_id,
+    struct sigevent *__restrict __evp,
+    timer_t *__restrict __timerid) throw ();
+
+
+extern int timer_delete (timer_t __timerid) throw ();
+
+
+extern int timer_settime (timer_t __timerid, int __flags,
+     __const struct itimerspec *__restrict __value,
+     struct itimerspec *__restrict __ovalue) throw ();
+
+
+extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
+     throw ();
+
+
+extern int timer_getoverrun (timer_t __timerid) throw ();
+# 390 "/usr/include/time.h" 3 4
+extern int getdate_err;
+# 399 "/usr/include/time.h" 3 4
+extern struct tm *getdate (__const char *__string);
+# 413 "/usr/include/time.h" 3 4
+extern int getdate_r (__const char *__restrict __string,
+        struct tm *__restrict __resbufp);
+
+
+}
+# 27 "/usr/include/pthread.h" 2 3 4
+
+
+# 1 "/usr/include/signal.h" 1 3 4
+# 31 "/usr/include/signal.h" 3 4
+extern "C" {
+
+# 1 "/usr/include/bits/sigset.h" 1 3 4
+# 24 "/usr/include/bits/sigset.h" 3 4
+typedef int __sig_atomic_t;
+
+
+
+
+typedef struct
+  {
+    unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
+  } __sigset_t;
+# 34 "/usr/include/signal.h" 2 3 4
+# 50 "/usr/include/signal.h" 3 4
+typedef __sigset_t sigset_t;
+# 408 "/usr/include/signal.h" 3 4
+}
+# 30 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
+# 23 "/usr/include/bits/pthreadtypes.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4
+# 50 "/usr/include/bits/pthreadtypes.h" 3 4
+typedef unsigned long int pthread_t;
+
+
+typedef union
+{
+  char __size[56];
+  long int __align;
+} pthread_attr_t;
+
+
+
+typedef struct __pthread_internal_list
+{
+  struct __pthread_internal_list *__prev;
+  struct __pthread_internal_list *__next;
+} __pthread_list_t;
+# 76 "/usr/include/bits/pthreadtypes.h" 3 4
+typedef union
+{
+  struct __pthread_mutex_s
+  {
+    int __lock;
+    unsigned int __count;
+    int __owner;
+
+    unsigned int __nusers;
+
+
+
+    int __kind;
+
+    int __spins;
+    __pthread_list_t __list;
+# 101 "/usr/include/bits/pthreadtypes.h" 3 4
+  } __data;
+  char __size[40];
+  long int __align;
+} pthread_mutex_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_mutexattr_t;
+
+
+
+
+typedef union
+{
+  struct
+  {
+    int __lock;
+    unsigned int __futex;
+    __extension__ unsigned long long int __total_seq;
+    __extension__ unsigned long long int __wakeup_seq;
+    __extension__ unsigned long long int __woken_seq;
+    void *__mutex;
+    unsigned int __nwaiters;
+    unsigned int __broadcast_seq;
+  } __data;
+  char __size[48];
+  __extension__ long long int __align;
+} pthread_cond_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_condattr_t;
+
+
+
+typedef unsigned int pthread_key_t;
+
+
+
+typedef int pthread_once_t;
+
+
+
+
+
+typedef union
+{
+
+  struct
+  {
+    int __lock;
+    unsigned int __nr_readers;
+    unsigned int __readers_wakeup;
+    unsigned int __writer_wakeup;
+    unsigned int __nr_readers_queued;
+    unsigned int __nr_writers_queued;
+    int __writer;
+    int __shared;
+    unsigned long int __pad1;
+    unsigned long int __pad2;
+
+
+    unsigned int __flags;
+  } __data;
+# 187 "/usr/include/bits/pthreadtypes.h" 3 4
+  char __size[56];
+  long int __align;
+} pthread_rwlock_t;
+
+typedef union
+{
+  char __size[8];
+  long int __align;
+} pthread_rwlockattr_t;
+
+
+
+
+
+typedef volatile int pthread_spinlock_t;
+
+
+
+
+typedef union
+{
+  char __size[32];
+  long int __align;
+} pthread_barrier_t;
+
+typedef union
+{
+  char __size[4];
+  int __align;
+} pthread_barrierattr_t;
+# 31 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/setjmp.h" 1 3 4
+# 27 "/usr/include/bits/setjmp.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 28 "/usr/include/bits/setjmp.h" 2 3 4
+
+
+
+
+typedef long int __jmp_buf[8];
+# 32 "/usr/include/pthread.h" 2 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 33 "/usr/include/pthread.h" 2 3 4
+
+
+
+enum
+{
+  PTHREAD_CREATE_JOINABLE,
+
+  PTHREAD_CREATE_DETACHED
+
+};
+
+
+
+enum
+{
+  PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_ADAPTIVE_NP
+
+  ,
+  PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
+  PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
+  PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
+  PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
+
+
+
+  , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP
+
+};
+
+
+
+
+enum
+{
+  PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED,
+  PTHREAD_MUTEX_ROBUST,
+  PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST
+};
+
+
+
+
+
+enum
+{
+  PTHREAD_PRIO_NONE,
+  PTHREAD_PRIO_INHERIT,
+  PTHREAD_PRIO_PROTECT
+};
+# 117 "/usr/include/pthread.h" 3 4
+enum
+{
+  PTHREAD_RWLOCK_PREFER_READER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NP,
+  PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
+  PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP
+};
+# 149 "/usr/include/pthread.h" 3 4
+enum
+{
+  PTHREAD_INHERIT_SCHED,
+
+  PTHREAD_EXPLICIT_SCHED
+
+};
+
+
+
+enum
+{
+  PTHREAD_SCOPE_SYSTEM,
+
+  PTHREAD_SCOPE_PROCESS
+
+};
+
+
+
+enum
+{
+  PTHREAD_PROCESS_PRIVATE,
+
+  PTHREAD_PROCESS_SHARED
+
+};
+# 184 "/usr/include/pthread.h" 3 4
+struct _pthread_cleanup_buffer
+{
+  void (*__routine) (void *);
+  void *__arg;
+  int __canceltype;
+  struct _pthread_cleanup_buffer *__prev;
+};
+
+
+enum
+{
+  PTHREAD_CANCEL_ENABLE,
+
+  PTHREAD_CANCEL_DISABLE
+
+};
+enum
+{
+  PTHREAD_CANCEL_DEFERRED,
+
+  PTHREAD_CANCEL_ASYNCHRONOUS
+
+};
+# 222 "/usr/include/pthread.h" 3 4
+extern "C" {
+
+
+
+
+extern int pthread_create (pthread_t *__restrict __newthread,
+      __const pthread_attr_t *__restrict __attr,
+      void *(*__start_routine) (void *),
+      void *__restrict __arg) throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+
+extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern int pthread_join (pthread_t __th, void **__thread_return);
+
+
+
+
+extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) throw ();
+
+
+
+
+
+
+
+extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
+     __const struct timespec *__abstime);
+
+
+
+
+
+
+extern int pthread_detach (pthread_t __th) throw ();
+
+
+
+extern pthread_t pthread_self (void) throw () __attribute__ ((__const__));
+
+
+extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ();
+
+
+
+
+
+
+
+extern int pthread_attr_init (pthread_attr_t *__attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_destroy (pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr,
+     int *__detachstate)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+     int __detachstate)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getguardsize (__const pthread_attr_t *__attr,
+          size_t *__guardsize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
+          size_t __guardsize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict
+           __attr,
+           struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
+           __const struct sched_param *__restrict
+           __param) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict
+     __attr, int *__restrict __policy)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict
+      __attr, int *__restrict __inherit)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
+      int __inherit)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr,
+      int *__restrict __scope)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict
+          __attr, void **__restrict __stackaddr)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));
+
+
+
+
+
+extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
+          void *__stackaddr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));
+
+
+extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict
+          __attr, size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
+          size_t __stacksize)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr,
+      void **__restrict __stackaddr,
+      size_t *__restrict __stacksize)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
+      size_t __stacksize) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     __const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+extern int pthread_attr_getaffinity_np (__const pthread_attr_t *__attr,
+     size_t __cpusetsize,
+     cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+
+extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+
+extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
+      __const struct sched_param *__param)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getschedparam (pthread_t __target_thread,
+      int *__restrict __policy,
+      struct sched_param *__restrict __param)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
+     throw ();
+
+
+
+
+extern int pthread_getconcurrency (void) throw ();
+
+
+extern int pthread_setconcurrency (int __level) throw ();
+
+
+
+
+
+
+
+extern int pthread_yield (void) throw ();
+
+
+
+
+extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
+       __const cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+
+
+extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
+       cpu_set_t *__cpuset)
+     throw () __attribute__ ((__nonnull__ (3)));
+# 468 "/usr/include/pthread.h" 3 4
+extern int pthread_once (pthread_once_t *__once_control,
+    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
+# 480 "/usr/include/pthread.h" 3 4
+extern int pthread_setcancelstate (int __state, int *__oldstate);
+
+
+
+extern int pthread_setcanceltype (int __type, int *__oldtype);
+
+
+extern int pthread_cancel (pthread_t __th);
+
+
+
+
+extern void pthread_testcancel (void);
+
+
+
+
+typedef struct
+{
+  struct
+  {
+    __jmp_buf __cancel_jmp_buf;
+    int __mask_was_saved;
+  } __cancel_jmp_buf[1];
+  void *__pad[4];
+} __pthread_unwind_buf_t __attribute__ ((__aligned__));
+# 514 "/usr/include/pthread.h" 3 4
+struct __pthread_cleanup_frame
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+};
+
+
+
+
+class __pthread_cleanup_class
+{
+  void (*__cancel_routine) (void *);
+  void *__cancel_arg;
+  int __do_it;
+  int __cancel_type;
+
+ public:
+  __pthread_cleanup_class (void (*__fct) (void *), void *__arg)
+    : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { }
+  ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); }
+  void __setdoit (int __newval) { __do_it = __newval; }
+  void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED,
+        &__cancel_type); }
+  void __restore () const { pthread_setcanceltype (__cancel_type, 0); }
+};
+# 716 "/usr/include/pthread.h" 3 4
+struct __jmp_buf_tag;
+extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) throw ();
+
+
+
+
+
+extern int pthread_mutex_init (pthread_mutex_t *__mutex,
+          __const pthread_mutexattr_t *__mutexattr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
+                                    __const struct timespec *__restrict
+                                    __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int pthread_mutex_getprioceiling (__const pthread_mutex_t *
+      __restrict __mutex,
+      int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
+      int __prioceiling,
+      int *__restrict __old_ceiling)
+     throw () __attribute__ ((__nonnull__ (1, 3)));
+
+
+
+
+
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutex_consistent_np (pthread_mutex_t *__mutex)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 782 "/usr/include/pthread.h" 3 4
+extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t *
+      __restrict __attr,
+      int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
+      int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict
+          __attr, int *__restrict __kind)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getprotocol (__const pthread_mutexattr_t *
+       __restrict __attr,
+       int *__restrict __protocol)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
+       int __protocol)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_mutexattr_getprioceiling (__const pthread_mutexattr_t *
+          __restrict __attr,
+          int *__restrict __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
+          int __prioceiling)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int pthread_mutexattr_getrobust (__const pthread_mutexattr_t *__attr,
+     int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int pthread_mutexattr_getrobust_np (__const pthread_mutexattr_t *__attr,
+        int *__robustness)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
+     int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *__attr,
+        int __robustness)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 864 "/usr/include/pthread.h" 3 4
+extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
+    __const pthread_rwlockattr_t *__restrict
+    __attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
+  throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
+           __const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
+           __const struct timespec *__restrict
+           __abstime) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
+       int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *
+       __restrict __attr,
+       int *__restrict __pref)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
+       int __pref) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
+         __const pthread_condattr_t *__restrict
+         __cond_attr) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_destroy (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_signal (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_cond_broadcast (pthread_cond_t *__cond)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
+         pthread_mutex_t *__restrict __mutex)
+     __attribute__ ((__nonnull__ (1, 2)));
+# 976 "/usr/include/pthread.h" 3 4
+extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond,
+       pthread_mutex_t *__restrict __mutex,
+       __const struct timespec *__restrict
+       __abstime) __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+extern int pthread_condattr_init (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_condattr_getpshared (__const pthread_condattr_t *
+                                        __restrict __attr,
+                                        int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
+                                        int __pshared) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_condattr_getclock (__const pthread_condattr_t *
+          __restrict __attr,
+          __clockid_t *__restrict __clock_id)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
+          __clockid_t __clock_id)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1020 "/usr/include/pthread.h" 3 4
+extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_lock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
+     __const pthread_barrierattr_t *__restrict
+     __attr, unsigned int __count)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_barrierattr_getpshared (__const pthread_barrierattr_t *
+        __restrict __attr,
+        int *__restrict __pshared)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
+                                           int __pshared)
+     throw () __attribute__ ((__nonnull__ (1)));
+# 1087 "/usr/include/pthread.h" 3 4
+extern int pthread_key_create (pthread_key_t *__key,
+          void (*__destr_function) (void *))
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int pthread_key_delete (pthread_key_t __key) throw ();
+
+
+extern void *pthread_getspecific (pthread_key_t __key) throw ();
+
+
+extern int pthread_setspecific (pthread_key_t __key,
+    __const void *__pointer) throw () ;
+
+
+
+
+extern int pthread_getcpuclockid (pthread_t __thread_id,
+      __clockid_t *__clock_id)
+     throw () __attribute__ ((__nonnull__ (2)));
+# 1121 "/usr/include/pthread.h" 3 4
+extern int pthread_atfork (void (*__prepare) (void),
+      void (*__parent) (void),
+      void (*__child) (void)) throw ();
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+pthread_equal (pthread_t __thread1, pthread_t __thread2) throw ()
+{
+  return __thread1 == __thread2;
+}
+
+
+}
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
+# 1 "/usr/include/unistd.h" 1 3 4
+# 28 "/usr/include/unistd.h" 3 4
+extern "C" {
+# 203 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/bits/posix_opt.h" 1 3 4
+# 204 "/usr/include/unistd.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/environments.h" 1 3 4
+# 23 "/usr/include/bits/environments.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 24 "/usr/include/bits/environments.h" 2 3 4
+# 208 "/usr/include/unistd.h" 2 3 4
+# 221 "/usr/include/unistd.h" 3 4
+typedef __ssize_t ssize_t;
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 228 "/usr/include/unistd.h" 2 3 4
+
+
+
+
+
+typedef __gid_t gid_t;
+
+
+
+
+typedef __uid_t uid_t;
+
+
+
+
+
+typedef __off_t off_t;
+
+
+
+
+
+
+typedef __off64_t off64_t;
+
+
+
+
+typedef __useconds_t useconds_t;
+# 268 "/usr/include/unistd.h" 3 4
+typedef __intptr_t intptr_t;
+
+
+
+
+
+
+typedef __socklen_t socklen_t;
+# 288 "/usr/include/unistd.h" 3 4
+extern int access (__const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int euidaccess (__const char *__name, int __type)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int eaccess (__const char *__name, int __type)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int faccessat (int __fd, __const char *__file, int __type, int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
+# 331 "/usr/include/unistd.h" 3 4
+extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw ();
+# 342 "/usr/include/unistd.h" 3 4
+extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
+     throw ();
+
+
+
+
+
+
+extern int close (int __fd);
+
+
+
+
+
+
+extern ssize_t read (int __fd, void *__buf, size_t __nbytes) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern ssize_t write (int __fd, __const void *__buf, size_t __n) __attribute__ ((__warn_unused_result__));
+# 373 "/usr/include/unistd.h" 3 4
+extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
+        __off_t __offset) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n,
+         __off_t __offset) __attribute__ ((__warn_unused_result__));
+# 401 "/usr/include/unistd.h" 3 4
+extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
+   __off64_t __offset) __attribute__ ((__warn_unused_result__));
+
+
+extern ssize_t pwrite64 (int __fd, __const void *__buf, size_t __n,
+    __off64_t __offset) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+extern int pipe (int __pipedes[2]) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int pipe2 (int __pipedes[2], int __flags) throw () __attribute__ ((__warn_unused_result__));
+# 429 "/usr/include/unistd.h" 3 4
+extern unsigned int alarm (unsigned int __seconds) throw ();
+# 441 "/usr/include/unistd.h" 3 4
+extern unsigned int sleep (unsigned int __seconds);
+
+
+
+
+
+
+extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
+     throw ();
+
+
+
+
+
+
+extern int usleep (__useconds_t __useconds);
+# 465 "/usr/include/unistd.h" 3 4
+extern int pause (void);
+
+
+
+extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern int fchownat (int __fd, __const char *__file, __uid_t __owner,
+       __gid_t __group, int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern int chdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern int fchdir (int __fd) throw () __attribute__ ((__warn_unused_result__));
+# 507 "/usr/include/unistd.h" 3 4
+extern char *getcwd (char *__buf, size_t __size) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern char *get_current_dir_name (void) throw ();
+
+
+
+
+
+
+extern char *getwd (char *__buf)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int dup (int __fd) throw () __attribute__ ((__warn_unused_result__));
+
+
+extern int dup2 (int __fd, int __fd2) throw ();
+
+
+
+
+extern int dup3 (int __fd, int __fd2, int __flags) throw ();
+
+
+
+extern char **__environ;
+
+extern char **environ;
+
+
+
+
+
+extern int execve (__const char *__path, char *__const __argv[],
+     char *__const __envp[]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int fexecve (int __fd, char *__const __argv[], char *__const __envp[])
+     throw ();
+
+
+
+
+extern int execv (__const char *__path, char *__const __argv[])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int execle (__const char *__path, __const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int execl (__const char *__path, __const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int execvp (__const char *__file, char *__const __argv[])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int execlp (__const char *__file, __const char *__arg, ...)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int execvpe (__const char *__file, char *__const __argv[],
+      char *__const __envp[])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int nice (int __inc) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern void _exit (int __status) __attribute__ ((__noreturn__));
+
+
+
+
+
+# 1 "/usr/include/bits/confname.h" 1 3 4
+# 26 "/usr/include/bits/confname.h" 3 4
+enum
+  {
+    _PC_LINK_MAX,
+
+    _PC_MAX_CANON,
+
+    _PC_MAX_INPUT,
+
+    _PC_NAME_MAX,
+
+    _PC_PATH_MAX,
+
+    _PC_PIPE_BUF,
+
+    _PC_CHOWN_RESTRICTED,
+
+    _PC_NO_TRUNC,
+
+    _PC_VDISABLE,
+
+    _PC_SYNC_IO,
+
+    _PC_ASYNC_IO,
+
+    _PC_PRIO_IO,
+
+    _PC_SOCK_MAXBUF,
+
+    _PC_FILESIZEBITS,
+
+    _PC_REC_INCR_XFER_SIZE,
+
+    _PC_REC_MAX_XFER_SIZE,
+
+    _PC_REC_MIN_XFER_SIZE,
+
+    _PC_REC_XFER_ALIGN,
+
+    _PC_ALLOC_SIZE_MIN,
+
+    _PC_SYMLINK_MAX,
+
+    _PC_2_SYMLINKS
+
+  };
+
+
+enum
+  {
+    _SC_ARG_MAX,
+
+    _SC_CHILD_MAX,
+
+    _SC_CLK_TCK,
+
+    _SC_NGROUPS_MAX,
+
+    _SC_OPEN_MAX,
+
+    _SC_STREAM_MAX,
+
+    _SC_TZNAME_MAX,
+
+    _SC_JOB_CONTROL,
+
+    _SC_SAVED_IDS,
+
+    _SC_REALTIME_SIGNALS,
+
+    _SC_PRIORITY_SCHEDULING,
+
+    _SC_TIMERS,
+
+    _SC_ASYNCHRONOUS_IO,
+
+    _SC_PRIORITIZED_IO,
+
+    _SC_SYNCHRONIZED_IO,
+
+    _SC_FSYNC,
+
+    _SC_MAPPED_FILES,
+
+    _SC_MEMLOCK,
+
+    _SC_MEMLOCK_RANGE,
+
+    _SC_MEMORY_PROTECTION,
+
+    _SC_MESSAGE_PASSING,
+
+    _SC_SEMAPHORES,
+
+    _SC_SHARED_MEMORY_OBJECTS,
+
+    _SC_AIO_LISTIO_MAX,
+
+    _SC_AIO_MAX,
+
+    _SC_AIO_PRIO_DELTA_MAX,
+
+    _SC_DELAYTIMER_MAX,
+
+    _SC_MQ_OPEN_MAX,
+
+    _SC_MQ_PRIO_MAX,
+
+    _SC_VERSION,
+
+    _SC_PAGESIZE,
+
+
+    _SC_RTSIG_MAX,
+
+    _SC_SEM_NSEMS_MAX,
+
+    _SC_SEM_VALUE_MAX,
+
+    _SC_SIGQUEUE_MAX,
+
+    _SC_TIMER_MAX,
+
+
+
+
+    _SC_BC_BASE_MAX,
+
+    _SC_BC_DIM_MAX,
+
+    _SC_BC_SCALE_MAX,
+
+    _SC_BC_STRING_MAX,
+
+    _SC_COLL_WEIGHTS_MAX,
+
+    _SC_EQUIV_CLASS_MAX,
+
+    _SC_EXPR_NEST_MAX,
+
+    _SC_LINE_MAX,
+
+    _SC_RE_DUP_MAX,
+
+    _SC_CHARCLASS_NAME_MAX,
+
+
+    _SC_2_VERSION,
+
+    _SC_2_C_BIND,
+
+    _SC_2_C_DEV,
+
+    _SC_2_FORT_DEV,
+
+    _SC_2_FORT_RUN,
+
+    _SC_2_SW_DEV,
+
+    _SC_2_LOCALEDEF,
+
+
+    _SC_PII,
+
+    _SC_PII_XTI,
+
+    _SC_PII_SOCKET,
+
+    _SC_PII_INTERNET,
+
+    _SC_PII_OSI,
+
+    _SC_POLL,
+
+    _SC_SELECT,
+
+    _SC_UIO_MAXIOV,
+
+    _SC_IOV_MAX = _SC_UIO_MAXIOV,
+
+    _SC_PII_INTERNET_STREAM,
+
+    _SC_PII_INTERNET_DGRAM,
+
+    _SC_PII_OSI_COTS,
+
+    _SC_PII_OSI_CLTS,
+
+    _SC_PII_OSI_M,
+
+    _SC_T_IOV_MAX,
+
+
+
+    _SC_THREADS,
+
+    _SC_THREAD_SAFE_FUNCTIONS,
+
+    _SC_GETGR_R_SIZE_MAX,
+
+    _SC_GETPW_R_SIZE_MAX,
+
+    _SC_LOGIN_NAME_MAX,
+
+    _SC_TTY_NAME_MAX,
+
+    _SC_THREAD_DESTRUCTOR_ITERATIONS,
+
+    _SC_THREAD_KEYS_MAX,
+
+    _SC_THREAD_STACK_MIN,
+
+    _SC_THREAD_THREADS_MAX,
+
+    _SC_THREAD_ATTR_STACKADDR,
+
+    _SC_THREAD_ATTR_STACKSIZE,
+
+    _SC_THREAD_PRIORITY_SCHEDULING,
+
+    _SC_THREAD_PRIO_INHERIT,
+
+    _SC_THREAD_PRIO_PROTECT,
+
+    _SC_THREAD_PROCESS_SHARED,
+
+
+    _SC_NPROCESSORS_CONF,
+
+    _SC_NPROCESSORS_ONLN,
+
+    _SC_PHYS_PAGES,
+
+    _SC_AVPHYS_PAGES,
+
+    _SC_ATEXIT_MAX,
+
+    _SC_PASS_MAX,
+
+
+    _SC_XOPEN_VERSION,
+
+    _SC_XOPEN_XCU_VERSION,
+
+    _SC_XOPEN_UNIX,
+
+    _SC_XOPEN_CRYPT,
+
+    _SC_XOPEN_ENH_I18N,
+
+    _SC_XOPEN_SHM,
+
+
+    _SC_2_CHAR_TERM,
+
+    _SC_2_C_VERSION,
+
+    _SC_2_UPE,
+
+
+    _SC_XOPEN_XPG2,
+
+    _SC_XOPEN_XPG3,
+
+    _SC_XOPEN_XPG4,
+
+
+    _SC_CHAR_BIT,
+
+    _SC_CHAR_MAX,
+
+    _SC_CHAR_MIN,
+
+    _SC_INT_MAX,
+
+    _SC_INT_MIN,
+
+    _SC_LONG_BIT,
+
+    _SC_WORD_BIT,
+
+    _SC_MB_LEN_MAX,
+
+    _SC_NZERO,
+
+    _SC_SSIZE_MAX,
+
+    _SC_SCHAR_MAX,
+
+    _SC_SCHAR_MIN,
+
+    _SC_SHRT_MAX,
+
+    _SC_SHRT_MIN,
+
+    _SC_UCHAR_MAX,
+
+    _SC_UINT_MAX,
+
+    _SC_ULONG_MAX,
+
+    _SC_USHRT_MAX,
+
+
+    _SC_NL_ARGMAX,
+
+    _SC_NL_LANGMAX,
+
+    _SC_NL_MSGMAX,
+
+    _SC_NL_NMAX,
+
+    _SC_NL_SETMAX,
+
+    _SC_NL_TEXTMAX,
+
+
+    _SC_XBS5_ILP32_OFF32,
+
+    _SC_XBS5_ILP32_OFFBIG,
+
+    _SC_XBS5_LP64_OFF64,
+
+    _SC_XBS5_LPBIG_OFFBIG,
+
+
+    _SC_XOPEN_LEGACY,
+
+    _SC_XOPEN_REALTIME,
+
+    _SC_XOPEN_REALTIME_THREADS,
+
+
+    _SC_ADVISORY_INFO,
+
+    _SC_BARRIERS,
+
+    _SC_BASE,
+
+    _SC_C_LANG_SUPPORT,
+
+    _SC_C_LANG_SUPPORT_R,
+
+    _SC_CLOCK_SELECTION,
+
+    _SC_CPUTIME,
+
+    _SC_THREAD_CPUTIME,
+
+    _SC_DEVICE_IO,
+
+    _SC_DEVICE_SPECIFIC,
+
+    _SC_DEVICE_SPECIFIC_R,
+
+    _SC_FD_MGMT,
+
+    _SC_FIFO,
+
+    _SC_PIPE,
+
+    _SC_FILE_ATTRIBUTES,
+
+    _SC_FILE_LOCKING,
+
+    _SC_FILE_SYSTEM,
+
+    _SC_MONOTONIC_CLOCK,
+
+    _SC_MULTI_PROCESS,
+
+    _SC_SINGLE_PROCESS,
+
+    _SC_NETWORKING,
+
+    _SC_READER_WRITER_LOCKS,
+
+    _SC_SPIN_LOCKS,
+
+    _SC_REGEXP,
+
+    _SC_REGEX_VERSION,
+
+    _SC_SHELL,
+
+    _SC_SIGNALS,
+
+    _SC_SPAWN,
+
+    _SC_SPORADIC_SERVER,
+
+    _SC_THREAD_SPORADIC_SERVER,
+
+    _SC_SYSTEM_DATABASE,
+
+    _SC_SYSTEM_DATABASE_R,
+
+    _SC_TIMEOUTS,
+
+    _SC_TYPED_MEMORY_OBJECTS,
+
+    _SC_USER_GROUPS,
+
+    _SC_USER_GROUPS_R,
+
+    _SC_2_PBS,
+
+    _SC_2_PBS_ACCOUNTING,
+
+    _SC_2_PBS_LOCATE,
+
+    _SC_2_PBS_MESSAGE,
+
+    _SC_2_PBS_TRACK,
+
+    _SC_SYMLOOP_MAX,
+
+    _SC_STREAMS,
+
+    _SC_2_PBS_CHECKPOINT,
+
+
+    _SC_V6_ILP32_OFF32,
+
+    _SC_V6_ILP32_OFFBIG,
+
+    _SC_V6_LP64_OFF64,
+
+    _SC_V6_LPBIG_OFFBIG,
+
+
+    _SC_HOST_NAME_MAX,
+
+    _SC_TRACE,
+
+    _SC_TRACE_EVENT_FILTER,
+
+    _SC_TRACE_INHERIT,
+
+    _SC_TRACE_LOG,
+
+
+    _SC_LEVEL1_ICACHE_SIZE,
+
+    _SC_LEVEL1_ICACHE_ASSOC,
+
+    _SC_LEVEL1_ICACHE_LINESIZE,
+
+    _SC_LEVEL1_DCACHE_SIZE,
+
+    _SC_LEVEL1_DCACHE_ASSOC,
+
+    _SC_LEVEL1_DCACHE_LINESIZE,
+
+    _SC_LEVEL2_CACHE_SIZE,
+
+    _SC_LEVEL2_CACHE_ASSOC,
+
+    _SC_LEVEL2_CACHE_LINESIZE,
+
+    _SC_LEVEL3_CACHE_SIZE,
+
+    _SC_LEVEL3_CACHE_ASSOC,
+
+    _SC_LEVEL3_CACHE_LINESIZE,
+
+    _SC_LEVEL4_CACHE_SIZE,
+
+    _SC_LEVEL4_CACHE_ASSOC,
+
+    _SC_LEVEL4_CACHE_LINESIZE,
+
+
+
+    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,
+
+    _SC_RAW_SOCKETS,
+
+
+    _SC_V7_ILP32_OFF32,
+
+    _SC_V7_ILP32_OFFBIG,
+
+    _SC_V7_LP64_OFF64,
+
+    _SC_V7_LPBIG_OFFBIG,
+
+
+    _SC_SS_REPL_MAX,
+
+
+    _SC_TRACE_EVENT_NAME_MAX,
+
+    _SC_TRACE_NAME_MAX,
+
+    _SC_TRACE_SYS_MAX,
+
+    _SC_TRACE_USER_EVENT_MAX,
+
+
+    _SC_XOPEN_STREAMS,
+
+
+    _SC_THREAD_ROBUST_PRIO_INHERIT,
+
+    _SC_THREAD_ROBUST_PRIO_PROTECT,
+
+  };
+
+
+enum
+  {
+    _CS_PATH,
+
+
+    _CS_V6_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_GNU_LIBC_VERSION,
+
+    _CS_GNU_LIBPTHREAD_VERSION,
+
+
+    _CS_V5_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_V7_WIDTH_RESTRICTED_ENVS,
+
+
+
+    _CS_LFS_CFLAGS = 1000,
+
+    _CS_LFS_LDFLAGS,
+
+    _CS_LFS_LIBS,
+
+    _CS_LFS_LINTFLAGS,
+
+    _CS_LFS64_CFLAGS,
+
+    _CS_LFS64_LDFLAGS,
+
+    _CS_LFS64_LIBS,
+
+    _CS_LFS64_LINTFLAGS,
+
+
+    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,
+
+    _CS_XBS5_ILP32_OFF32_LDFLAGS,
+
+    _CS_XBS5_ILP32_OFF32_LIBS,
+
+    _CS_XBS5_ILP32_OFF32_LINTFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_CFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_XBS5_ILP32_OFFBIG_LIBS,
+
+    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_XBS5_LP64_OFF64_CFLAGS,
+
+    _CS_XBS5_LP64_OFF64_LDFLAGS,
+
+    _CS_XBS5_LP64_OFF64_LIBS,
+
+    _CS_XBS5_LP64_OFF64_LINTFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LIBS,
+
+    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LIBS,
+
+    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,
+
+    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_CFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,
+
+    _CS_POSIX_V6_LP64_OFF64_LIBS,
+
+    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,
+
+    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,
+
+
+    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LIBS,
+
+    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,
+
+    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_CFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,
+
+    _CS_POSIX_V7_LP64_OFF64_LIBS,
+
+    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,
+
+    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS
+
+  };
+# 605 "/usr/include/unistd.h" 2 3 4
+
+
+extern long int pathconf (__const char *__path, int __name)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int fpathconf (int __fd, int __name) throw ();
+
+
+extern long int sysconf (int __name) throw ();
+
+
+
+extern size_t confstr (int __name, char *__buf, size_t __len) throw ();
+
+
+
+
+extern __pid_t getpid (void) throw ();
+
+
+extern __pid_t getppid (void) throw ();
+
+
+
+
+extern __pid_t getpgrp (void) throw ();
+# 641 "/usr/include/unistd.h" 3 4
+extern __pid_t __getpgid (__pid_t __pid) throw ();
+
+extern __pid_t getpgid (__pid_t __pid) throw ();
+
+
+
+
+
+
+extern int setpgid (__pid_t __pid, __pid_t __pgid) throw ();
+# 667 "/usr/include/unistd.h" 3 4
+extern int setpgrp (void) throw ();
+# 684 "/usr/include/unistd.h" 3 4
+extern __pid_t setsid (void) throw ();
+
+
+
+extern __pid_t getsid (__pid_t __pid) throw ();
+
+
+
+extern __uid_t getuid (void) throw ();
+
+
+extern __uid_t geteuid (void) throw ();
+
+
+extern __gid_t getgid (void) throw ();
+
+
+extern __gid_t getegid (void) throw ();
+
+
+
+
+extern int getgroups (int __size, __gid_t __list[]) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+extern int group_member (__gid_t __gid) throw ();
+
+
+
+
+
+
+extern int setuid (__uid_t __uid) throw ();
+
+
+
+
+extern int setreuid (__uid_t __ruid, __uid_t __euid) throw ();
+
+
+
+
+extern int seteuid (__uid_t __uid) throw ();
+
+
+
+
+
+
+extern int setgid (__gid_t __gid) throw ();
+
+
+
+
+extern int setregid (__gid_t __rgid, __gid_t __egid) throw ();
+
+
+
+
+extern int setegid (__gid_t __gid) throw ();
+
+
+
+
+
+extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
+     throw ();
+
+
+
+extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
+     throw ();
+
+
+
+extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
+     throw ();
+
+
+
+extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
+     throw ();
+
+
+
+
+
+
+extern __pid_t fork (void) throw ();
+
+
+
+
+
+
+extern __pid_t vfork (void) throw ();
+
+
+
+
+
+extern char *ttyname (int __fd) throw ();
+
+
+
+extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern int isatty (int __fd) throw ();
+
+
+
+
+
+extern int ttyslot (void) throw ();
+
+
+
+
+extern int link (__const char *__from, __const char *__to)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int linkat (int __fromfd, __const char *__from, int __tofd,
+     __const char *__to, int __flags)
+     throw () __attribute__ ((__nonnull__ (2, 4))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int symlink (__const char *__from, __const char *__to)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern ssize_t readlink (__const char *__restrict __path,
+    char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int symlinkat (__const char *__from, int __tofd,
+        __const char *__to) throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+
+
+extern ssize_t readlinkat (int __fd, __const char *__restrict __path,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern int unlink (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int unlinkat (int __fd, __const char *__name, int __flag)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern int rmdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern __pid_t tcgetpgrp (int __fd) throw ();
+
+
+extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw ();
+
+
+
+
+
+
+extern char *getlogin (void);
+
+
+
+
+
+
+
+extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int setlogin (__const char *__name) throw () __attribute__ ((__nonnull__ (1)));
+# 887 "/usr/include/unistd.h" 3 4
+# 1 "/usr/include/getopt.h" 1 3 4
+# 50 "/usr/include/getopt.h" 3 4
+extern "C" {
+# 59 "/usr/include/getopt.h" 3 4
+extern char *optarg;
+# 73 "/usr/include/getopt.h" 3 4
+extern int optind;
+
+
+
+
+extern int opterr;
+
+
+
+extern int optopt;
+# 152 "/usr/include/getopt.h" 3 4
+extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
+       throw ();
+# 187 "/usr/include/getopt.h" 3 4
+}
+# 888 "/usr/include/unistd.h" 2 3 4
+
+
+
+
+
+
+
+extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int sethostname (__const char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern int sethostid (long int __id) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern int getdomainname (char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int setdomainname (__const char *__name, size_t __len)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern int vhangup (void) throw ();
+
+
+extern int revoke (__const char *__file) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+extern int profil (unsigned short int *__sample_buffer, size_t __size,
+     size_t __offset, unsigned int __scale)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int acct (__const char *__name) throw ();
+
+
+
+extern char *getusershell (void) throw ();
+extern void endusershell (void) throw ();
+extern void setusershell (void) throw ();
+
+
+
+
+
+extern int daemon (int __nochdir, int __noclose) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern int chroot (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern char *getpass (__const char *__prompt) __attribute__ ((__nonnull__ (1)));
+# 973 "/usr/include/unistd.h" 3 4
+extern int fsync (int __fd);
+
+
+
+
+
+
+extern long int gethostid (void);
+
+
+extern void sync (void) throw ();
+
+
+
+
+extern int getpagesize (void) throw () __attribute__ ((__const__));
+
+
+
+
+extern int getdtablesize (void) throw ();
+
+
+
+
+extern int truncate (__const char *__file, __off_t __length)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 1010 "/usr/include/unistd.h" 3 4
+extern int truncate64 (__const char *__file, __off64_t __length)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 1020 "/usr/include/unistd.h" 3 4
+extern int ftruncate (int __fd, __off_t __length) throw () __attribute__ ((__warn_unused_result__));
+# 1030 "/usr/include/unistd.h" 3 4
+extern int ftruncate64 (int __fd, __off64_t __length) throw () __attribute__ ((__warn_unused_result__));
+# 1040 "/usr/include/unistd.h" 3 4
+extern int brk (void *__addr) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern void *sbrk (intptr_t __delta) throw ();
+# 1061 "/usr/include/unistd.h" 3 4
+extern long int syscall (long int __sysno, ...) throw ();
+# 1084 "/usr/include/unistd.h" 3 4
+extern int lockf (int __fd, int __cmd, __off_t __len) __attribute__ ((__warn_unused_result__));
+# 1094 "/usr/include/unistd.h" 3 4
+extern int lockf64 (int __fd, int __cmd, __off64_t __len) __attribute__ ((__warn_unused_result__));
+# 1115 "/usr/include/unistd.h" 3 4
+extern int fdatasync (int __fildes);
+
+
+
+
+
+
+
+extern char *crypt (__const char *__key, __const char *__salt)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern void swab (__const void *__restrict __from, void *__restrict __to,
+    ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+
+extern char *ctermid (char *__s) throw ();
+
+
+
+
+
+# 1 "/usr/include/bits/unistd.h" 1 3 4
+# 24 "/usr/include/bits/unistd.h" 3 4
+extern ssize_t __read_chk (int __fd, void *__buf, size_t __nbytes,
+      size_t __buflen) __attribute__ ((__warn_unused_result__));
+extern ssize_t __read_alias (int __fd, void *__buf, size_t __nbytes) __asm__ ("" "read")
+                               __attribute__ ((__warn_unused_result__));
+extern ssize_t __read_chk_warn (int __fd, void *__buf, size_t __nbytes, size_t __buflen) __asm__ ("" "__read_chk")
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("read called with bigger length than size of " "the destination buffer")))
+                                  ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
+read (int __fd, void *__buf, size_t __nbytes)
+{
+  if (__builtin_object_size (__buf, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__nbytes))
+ return __read_chk (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
+
+      if (__nbytes > __builtin_object_size (__buf, 0))
+ return __read_chk_warn (__fd, __buf, __nbytes, __builtin_object_size (__buf, 0));
+    }
+  return __read_alias (__fd, __buf, __nbytes);
+}
+
+
+extern ssize_t __pread_chk (int __fd, void *__buf, size_t __nbytes,
+       __off_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread64_chk (int __fd, void *__buf, size_t __nbytes,
+         __off64_t __offset, size_t __bufsize) __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread_alias (int __fd, void *__buf, size_t __nbytes, __off_t __offset) __asm__ ("" "pread")
+
+                                 __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread64_alias (int __fd, void *__buf, size_t __nbytes, __off64_t __offset) __asm__ ("" "pread64")
+
+                                     __attribute__ ((__warn_unused_result__));
+extern ssize_t __pread_chk_warn (int __fd, void *__buf, size_t __nbytes, __off_t __offset, size_t __bufsize) __asm__ ("" "__pread_chk")
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread called with bigger length than size of " "the destination buffer")))
+                                  ;
+extern ssize_t __pread64_chk_warn (int __fd, void *__buf, size_t __nbytes, __off64_t __offset, size_t __bufsize) __asm__ ("" "__pread64_chk")
+
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("pread64 called with bigger length than size of " "the destination buffer")))
+                                  ;
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
+pread (int __fd, void *__buf, size_t __nbytes, __off_t __offset)
+{
+  if (__builtin_object_size (__buf, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__nbytes))
+ return __pread_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
+
+      if ( __nbytes > __builtin_object_size (__buf, 0))
+ return __pread_chk_warn (__fd, __buf, __nbytes, __offset,
+     __builtin_object_size (__buf, 0));
+    }
+  return __pread_alias (__fd, __buf, __nbytes, __offset);
+}
+# 105 "/usr/include/bits/unistd.h" 3 4
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) ssize_t
+pread64 (int __fd, void *__buf, size_t __nbytes, __off64_t __offset)
+{
+  if (__builtin_object_size (__buf, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__nbytes))
+ return __pread64_chk (__fd, __buf, __nbytes, __offset, __builtin_object_size (__buf, 0));
+
+      if ( __nbytes > __builtin_object_size (__buf, 0))
+ return __pread64_chk_warn (__fd, __buf, __nbytes, __offset,
+       __builtin_object_size (__buf, 0));
+    }
+
+  return __pread64_alias (__fd, __buf, __nbytes, __offset);
+}
+
+
+
+
+extern ssize_t __readlink_chk (__const char *__restrict __path,
+          char *__restrict __buf, size_t __len,
+          size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlink_alias (__const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlink")
+
+
+     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlink_chk_warn (__const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlink_chk")
+
+
+
+     __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlink called with bigger length " "than size of destination buffer")))
+                                         ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__warn_unused_result__)) ssize_t
+readlink (__const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()
+
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __readlink_chk (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+
+      if ( __len > __builtin_object_size (__buf, 2 > 1))
+ return __readlink_chk_warn (__path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __readlink_alias (__path, __buf, __len);
+}
+
+
+
+extern ssize_t __readlinkat_chk (int __fd, __const char *__restrict __path,
+     char *__restrict __buf, size_t __len,
+     size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlinkat_alias (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len) throw () __asm__ ("" "readlinkat")
+
+
+
+     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__));
+extern ssize_t __readlinkat_chk_warn (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__readlinkat_chk")
+
+
+
+     __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("readlinkat called with bigger " "length than size of destination " "buffer")))
+
+                ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (2, 3))) __attribute__ ((__warn_unused_result__)) ssize_t
+readlinkat (int __fd, __const char *__restrict __path, char *__restrict __buf, size_t __len) throw ()
+
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __readlinkat_chk (__fd, __path, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+
+      if (__len > __builtin_object_size (__buf, 2 > 1))
+ return __readlinkat_chk_warn (__fd, __path, __buf, __len,
+          __builtin_object_size (__buf, 2 > 1));
+    }
+  return __readlinkat_alias (__fd, __path, __buf, __len);
+}
+
+
+extern char *__getcwd_chk (char *__buf, size_t __size, size_t __buflen)
+     throw () __attribute__ ((__warn_unused_result__));
+extern char *__getcwd_alias (char *__buf, size_t __size) throw () __asm__ ("" "getcwd")
+                                              __attribute__ ((__warn_unused_result__));
+extern char *__getcwd_chk_warn (char *__buf, size_t __size, size_t __buflen) throw () __asm__ ("" "__getcwd_chk")
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getcwd caller with bigger length than size of " "destination buffer")))
+                              ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+getcwd (char *__buf, size_t __size) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size))
+ return __getcwd_chk (__buf, __size, __builtin_object_size (__buf, 2 > 1));
+
+      if (__size > __builtin_object_size (__buf, 2 > 1))
+ return __getcwd_chk_warn (__buf, __size, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __getcwd_alias (__buf, __size);
+}
+
+
+extern char *__getwd_chk (char *__buf, size_t buflen)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern char *__getwd_warn (char *__buf) throw () __asm__ ("" "getwd")
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use getcwd instead, as getwd " "doesn't specify buffer size")))
+                                         ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)) __attribute__ ((__warn_unused_result__)) char *
+getwd (char *__buf) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    return __getwd_chk (__buf, __builtin_object_size (__buf, 2 > 1));
+  return __getwd_warn (__buf);
+}
+
+
+extern size_t __confstr_chk (int __name, char *__buf, size_t __len,
+        size_t __buflen) throw ();
+extern size_t __confstr_alias (int __name, char *__buf, size_t __len) throw () __asm__ ("" "confstr")
+                             ;
+extern size_t __confstr_chk_warn (int __name, char *__buf, size_t __len, size_t __buflen) throw () __asm__ ("" "__confstr_chk")
+
+
+     __attribute__((__warning__ ("confstr called with bigger length than size of destination " "buffer")))
+            ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+confstr (int __name, char *__buf, size_t __len) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __confstr_chk (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+
+      if (__builtin_object_size (__buf, 2 > 1) < __len)
+ return __confstr_chk_warn (__name, __buf, __len, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __confstr_alias (__name, __buf, __len);
+}
+
+
+extern int __getgroups_chk (int __size, __gid_t __list[], size_t __listlen)
+     throw () __attribute__ ((__warn_unused_result__));
+extern int __getgroups_alias (int __size, __gid_t __list[]) throw () __asm__ ("" "getgroups")
+                 __attribute__ ((__warn_unused_result__));
+extern int __getgroups_chk_warn (int __size, __gid_t __list[], size_t __listlen) throw () __asm__ ("" "__getgroups_chk")
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getgroups called with bigger group count than what " "can fit into destination buffer")))
+                                           ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+getgroups (int __size, __gid_t __list[]) throw ()
+{
+  if (__builtin_object_size (__list, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size) || __size < 0)
+ return __getgroups_chk (__size, __list, __builtin_object_size (__list, 2 > 1));
+
+      if (__size * sizeof (__gid_t) > __builtin_object_size (__list, 2 > 1))
+ return __getgroups_chk_warn (__size, __list, __builtin_object_size (__list, 2 > 1));
+    }
+  return __getgroups_alias (__size, __list);
+}
+
+
+extern int __ttyname_r_chk (int __fd, char *__buf, size_t __buflen,
+       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
+extern int __ttyname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ttyname_r")
+
+     __attribute__ ((__nonnull__ (2)));
+extern int __ttyname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ttyname_r_chk")
+
+
+     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ttyname_r called with bigger buflen than " "size of destination buffer")))
+                                  ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+ttyname_r (int __fd, char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __ttyname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __ttyname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __ttyname_r_alias (__fd, __buf, __buflen);
+}
+
+
+
+extern int __getlogin_r_chk (char *__buf, size_t __buflen, size_t __nreal)
+     __attribute__ ((__nonnull__ (1)));
+extern int __getlogin_r_alias (char *__buf, size_t __buflen) __asm__ ("" "getlogin_r")
+                     __attribute__ ((__nonnull__ (1)));
+extern int __getlogin_r_chk_warn (char *__buf, size_t __buflen, size_t __nreal) __asm__ ("" "__getlogin_r_chk")
+
+
+     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("getlogin_r called with bigger buflen than " "size of destination buffer")))
+                                  ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+getlogin_r (char *__buf, size_t __buflen)
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __getlogin_r_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __getlogin_r_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __getlogin_r_alias (__buf, __buflen);
+}
+
+
+
+
+extern int __gethostname_chk (char *__buf, size_t __buflen, size_t __nreal)
+     throw () __attribute__ ((__nonnull__ (1)));
+extern int __gethostname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "gethostname")
+                   __attribute__ ((__nonnull__ (1)));
+extern int __gethostname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__gethostname_chk")
+
+
+     __attribute__ ((__nonnull__ (1))) __attribute__((__warning__ ("gethostname called with bigger buflen than " "size of destination buffer")))
+                                  ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+gethostname (char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __gethostname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __gethostname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __gethostname_alias (__buf, __buflen);
+}
+
+
+
+
+extern int __getdomainname_chk (char *__buf, size_t __buflen, size_t __nreal)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int __getdomainname_alias (char *__buf, size_t __buflen) throw () __asm__ ("" "getdomainname")
+
+                     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+extern int __getdomainname_chk_warn (char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__getdomainname_chk")
+
+
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("getdomainname called with bigger " "buflen than size of destination " "buffer")))
+
+                    ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+getdomainname (char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __getdomainname_chk (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __getdomainname_chk_warn (__buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __getdomainname_alias (__buf, __buflen);
+}
+# 1151 "/usr/include/unistd.h" 2 3 4
+
+
+}
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3
+
+typedef pthread_t __gthread_t;
+typedef pthread_key_t __gthread_key_t;
+typedef pthread_once_t __gthread_once_t;
+typedef pthread_mutex_t __gthread_mutex_t;
+typedef pthread_mutex_t __gthread_recursive_mutex_t;
+typedef pthread_cond_t __gthread_cond_t;
+typedef struct timespec __gthread_time_t;
+# 118 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once")));
+static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific")));
+static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific")));
+
+static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create")));
+static __typeof(pthread_join) __gthrw_pthread_join __attribute__ ((__weakref__("pthread_join")));
+static __typeof(pthread_equal) __gthrw_pthread_equal __attribute__ ((__weakref__("pthread_equal")));
+static __typeof(pthread_self) __gthrw_pthread_self __attribute__ ((__weakref__("pthread_self")));
+static __typeof(pthread_detach) __gthrw_pthread_detach __attribute__ ((__weakref__("pthread_detach")));
+static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel")));
+static __typeof(sched_yield) __gthrw_sched_yield __attribute__ ((__weakref__("sched_yield")));
+
+static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock")));
+static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock")));
+
+
+static __typeof(pthread_mutex_timedlock) __gthrw_pthread_mutex_timedlock __attribute__ ((__weakref__("pthread_mutex_timedlock")));
+
+
+static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock")));
+static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init")));
+static __typeof(pthread_mutex_destroy) __gthrw_pthread_mutex_destroy __attribute__ ((__weakref__("pthread_mutex_destroy")));
+
+static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast")));
+static __typeof(pthread_cond_signal) __gthrw_pthread_cond_signal __attribute__ ((__weakref__("pthread_cond_signal")));
+static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait")));
+static __typeof(pthread_cond_timedwait) __gthrw_pthread_cond_timedwait __attribute__ ((__weakref__("pthread_cond_timedwait")));
+static __typeof(pthread_cond_destroy) __gthrw_pthread_cond_destroy __attribute__ ((__weakref__("pthread_cond_destroy")));
+
+
+static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create")));
+static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete")));
+static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init")));
+static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype")));
+static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy")));
+# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_active_p (void)
+{
+  static void *const __gthread_active_ptr
+    = __extension__ (void *) &__gthrw_pthread_cancel;
+  return __gthread_active_ptr != 0;
+}
+# 675 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+    void *__args)
+{
+  return __gthrw_pthread_create (__threadid, __null, __func, __args);
+}
+
+static inline int
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
+{
+  return __gthrw_pthread_join (__threadid, __value_ptr);
+}
+
+static inline int
+__gthread_detach (__gthread_t __threadid)
+{
+  return __gthrw_pthread_detach (__threadid);
+}
+
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  return __gthrw_pthread_equal (__t1, __t2);
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthrw_pthread_self ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+  return __gthrw_sched_yield ();
+}
+
+static inline int
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_once (__once, __func);
+  else
+    return -1;
+}
+
+static inline int
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
+{
+  return __gthrw_pthread_key_create (__key, __dtor);
+}
+
+static inline int
+__gthread_key_delete (__gthread_key_t __key)
+{
+  return __gthrw_pthread_key_delete (__key);
+}
+
+static inline void *
+__gthread_getspecific (__gthread_key_t __key)
+{
+  return __gthrw_pthread_getspecific (__key);
+}
+
+static inline int
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
+{
+  return __gthrw_pthread_setspecific (__key, __ptr);
+}
+
+static inline int
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_destroy (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_lock (__mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_trylock (__mutex);
+  else
+    return 0;
+}
+
+
+
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+      const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+
+
+static inline int
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthrw_pthread_mutex_unlock (__mutex);
+  else
+    return 0;
+}
+# 818 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr-default.h" 3
+static inline int
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_lock (__mutex);
+}
+
+static inline int
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_trylock (__mutex);
+}
+
+
+
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+         const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_mutex_timedlock (__mutex, __abs_timeout);
+}
+
+
+
+static inline int
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_mutex_unlock (__mutex);
+}
+
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_broadcast (__cond);
+}
+
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  return __gthrw_pthread_cond_signal (__cond);
+}
+
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  return __gthrw_pthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+     const __gthread_time_t *__abs_timeout)
+{
+  return __gthrw_pthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+          __gthread_recursive_mutex_t *__mutex)
+{
+  return __gthread_cond_wait (__cond, __mutex);
+}
+
+static inline int
+__gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
+        __gthread_recursive_mutex_t *__mutex,
+        const __gthread_time_t *__abs_timeout)
+{
+  return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* __cond)
+{
+  return __gthrw_pthread_cond_destroy (__cond);
+}
+# 163 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/gthr.h" 2 3
+
+
+
+
+
+
+
+#pragma GCC visibility pop
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3
+# 32 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/atomic_word.h" 3
+typedef int _Atomic_word;
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+
+  static inline _Atomic_word
+  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
+  { return __sync_fetch_and_add(__mem, __val); }
+
+  static inline void
+  __atomic_add(volatile _Atomic_word* __mem, int __val)
+  { __sync_fetch_and_add(__mem, __val); }
+# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ext/atomicity.h" 3
+  static inline _Atomic_word
+  __exchange_and_add_single(_Atomic_word* __mem, int __val)
+  {
+    _Atomic_word __result = *__mem;
+    *__mem += __val;
+    return __result;
+  }
+
+  static inline void
+  __atomic_add_single(_Atomic_word* __mem, int __val)
+  { *__mem += __val; }
+
+  static inline _Atomic_word
+  __attribute__ ((__unused__))
+  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      return __exchange_and_add(__mem, __val);
+    else
+      return __exchange_and_add_single(__mem, __val);
+
+
+
+  }
+
+  static inline void
+  __attribute__ ((__unused__))
+  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
+  {
+
+    if (__gthread_active_p())
+      __atomic_add(__mem, __val);
+    else
+      __atomic_add_single(__mem, __val);
+
+
+
+  }
+
+}
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 2 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/initializer_list" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/initializer_list" 3
+       
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/initializer_list" 3
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 103 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_string
+    {
+      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
+
+
+    public:
+      typedef _Traits traits_type;
+      typedef typename _Traits::char_type value_type;
+      typedef _Alloc allocator_type;
+      typedef typename _CharT_alloc_type::size_type size_type;
+      typedef typename _CharT_alloc_type::difference_type difference_type;
+      typedef typename _CharT_alloc_type::reference reference;
+      typedef typename _CharT_alloc_type::const_reference const_reference;
+      typedef typename _CharT_alloc_type::pointer pointer;
+      typedef typename _CharT_alloc_type::const_pointer const_pointer;
+      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
+                                                            const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+
+    private:
+# 140 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      struct _Rep_base
+      {
+ size_type _M_length;
+ size_type _M_capacity;
+ _Atomic_word _M_refcount;
+      };
+
+      struct _Rep : _Rep_base
+      {
+
+ typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc;
+# 165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+ static const size_type _S_max_size;
+ static const _CharT _S_terminal;
+
+
+
+        static size_type _S_empty_rep_storage[];
+
+        static _Rep&
+        _S_empty_rep()
+        {
+
+
+
+   void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage);
+   return *reinterpret_cast<_Rep*>(__p);
+ }
+
+        bool
+ _M_is_leaked() const
+        { return this->_M_refcount < 0; }
+
+        bool
+ _M_is_shared() const
+        { return this->_M_refcount > 0; }
+
+        void
+ _M_set_leaked()
+        { this->_M_refcount = -1; }
+
+        void
+ _M_set_sharable()
+        { this->_M_refcount = 0; }
+
+ void
+ _M_set_length_and_sharable(size_type __n)
+ {
+
+   if (__builtin_expect(this != &_S_empty_rep(), false))
+
+     {
+       this->_M_set_sharable();
+       this->_M_length = __n;
+       traits_type::assign(this->_M_refdata()[__n], _S_terminal);
+
+
+     }
+ }
+
+ _CharT*
+ _M_refdata() throw()
+ { return reinterpret_cast<_CharT*>(this + 1); }
+
+ _CharT*
+ _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2)
+ {
+   return (!_M_is_leaked() && __alloc1 == __alloc2)
+           ? _M_refcopy() : _M_clone(__alloc1);
+ }
+
+
+ static _Rep*
+ _S_create(size_type, size_type, const _Alloc&);
+
+ void
+ _M_dispose(const _Alloc& __a)
+ {
+
+   if (__builtin_expect(this != &_S_empty_rep(), false))
+
+     if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount,
+             -1) <= 0)
+       _M_destroy(__a);
+ }
+
+ void
+ _M_destroy(const _Alloc&) throw();
+
+ _CharT*
+ _M_refcopy() throw()
+ {
+
+   if (__builtin_expect(this != &_S_empty_rep(), false))
+
+            __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1);
+   return _M_refdata();
+ }
+
+ _CharT*
+ _M_clone(const _Alloc&, size_type __res = 0);
+      };
+
+
+      struct _Alloc_hider : _Alloc
+      {
+ _Alloc_hider(_CharT* __dat, const _Alloc& __a)
+ : _Alloc(__a), _M_p(__dat) { }
+
+ _CharT* _M_p;
+      };
+
+    public:
+
+
+
+
+      static const size_type npos = static_cast<size_type>(-1);
+
+    private:
+
+      mutable _Alloc_hider _M_dataplus;
+
+      _CharT*
+      _M_data() const
+      { return _M_dataplus._M_p; }
+
+      _CharT*
+      _M_data(_CharT* __p)
+      { return (_M_dataplus._M_p = __p); }
+
+      _Rep*
+      _M_rep() const
+      { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); }
+
+
+
+      iterator
+      _M_ibegin() const
+      { return iterator(_M_data()); }
+
+      iterator
+      _M_iend() const
+      { return iterator(_M_data() + this->size()); }
+
+      void
+      _M_leak()
+      {
+ if (!_M_rep()->_M_is_leaked())
+   _M_leak_hard();
+      }
+
+      size_type
+      _M_check(size_type __pos, const char* __s) const
+      {
+ if (__pos > this->size())
+   __throw_out_of_range((__s));
+ return __pos;
+      }
+
+      void
+      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
+      {
+ if (this->max_size() - (this->size() - __n1) < __n2)
+   __throw_length_error((__s));
+      }
+
+
+      size_type
+      _M_limit(size_type __pos, size_type __off) const
+      {
+ const bool __testoff = __off < this->size() - __pos;
+ return __testoff ? __off : this->size() - __pos;
+      }
+
+
+      bool
+      _M_disjunct(const _CharT* __s) const
+      {
+ return (less<const _CharT*>()(__s, _M_data())
+  || less<const _CharT*>()(_M_data() + this->size(), __s));
+      }
+
+
+
+      static void
+      _M_copy(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::copy(__d, __s, __n);
+      }
+
+      static void
+      _M_move(_CharT* __d, const _CharT* __s, size_type __n)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, *__s);
+ else
+   traits_type::move(__d, __s, __n);
+      }
+
+      static void
+      _M_assign(_CharT* __d, size_type __n, _CharT __c)
+      {
+ if (__n == 1)
+   traits_type::assign(*__d, __c);
+ else
+   traits_type::assign(__d, __n, __c);
+      }
+
+
+
+      template<class _Iterator>
+        static void
+        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
+        {
+   for (; __k1 != __k2; ++__k1, ++__p)
+     traits_type::assign(*__p, *__k1);
+ }
+
+      static void
+      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
+      { _S_copy_chars(__p, __k1.base(), __k2.base()); }
+
+      static void
+      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2)
+      { _M_copy(__p, __k1, __k2 - __k1); }
+
+      static void
+      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
+      { _M_copy(__p, __k1, __k2 - __k1); }
+
+      static int
+      _S_compare(size_type __n1, size_type __n2)
+      {
+ const difference_type __d = difference_type(__n1 - __n2);
+
+ if (__d > __gnu_cxx::__numeric_traits<int>::__max)
+   return __gnu_cxx::__numeric_traits<int>::__max;
+ else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
+   return __gnu_cxx::__numeric_traits<int>::__min;
+ else
+   return int(__d);
+      }
+
+      void
+      _M_mutate(size_type __pos, size_type __len1, size_type __len2);
+
+      void
+      _M_leak_hard();
+
+      static _Rep&
+      _S_empty_rep()
+      { return _Rep::_S_empty_rep(); }
+
+    public:
+
+
+
+
+
+
+
+      basic_string()
+
+      : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { }
+
+
+
+
+
+
+
+      explicit
+      basic_string(const _Alloc& __a);
+
+
+
+
+
+
+      basic_string(const basic_string& __str);
+
+
+
+
+
+
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n = npos);
+
+
+
+
+
+
+
+      basic_string(const basic_string& __str, size_type __pos,
+     size_type __n, const _Alloc& __a);
+# 468 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string(const _CharT* __s, size_type __n,
+     const _Alloc& __a = _Alloc());
+
+
+
+
+
+      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
+
+
+
+
+
+
+      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc());
+# 516 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      template<class _InputIterator>
+        basic_string(_InputIterator __beg, _InputIterator __end,
+       const _Alloc& __a = _Alloc());
+
+
+
+
+      ~basic_string()
+      { _M_rep()->_M_dispose(this->get_allocator()); }
+
+
+
+
+
+      basic_string&
+      operator=(const basic_string& __str)
+      { return this->assign(__str); }
+
+
+
+
+
+      basic_string&
+      operator=(const _CharT* __s)
+      { return this->assign(__s); }
+# 549 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      operator=(_CharT __c)
+      {
+ this->assign(1, __c);
+ return *this;
+      }
+# 589 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      iterator
+      begin()
+      {
+ _M_leak();
+ return iterator(_M_data());
+      }
+
+
+
+
+
+      const_iterator
+      begin() const
+      { return const_iterator(_M_data()); }
+
+
+
+
+
+      iterator
+      end()
+      {
+ _M_leak();
+ return iterator(_M_data() + this->size());
+      }
+
+
+
+
+
+      const_iterator
+      end() const
+      { return const_iterator(_M_data() + this->size()); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(this->end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(this->end()); }
+
+
+
+
+
+
+      reverse_iterator
+      rend()
+      { return reverse_iterator(this->begin()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(this->begin()); }
+# 695 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+    public:
+
+
+
+      size_type
+      size() const
+      { return _M_rep()->_M_length; }
+
+
+
+      size_type
+      length() const
+      { return _M_rep()->_M_length; }
+
+
+      size_type
+      max_size() const
+      { return _Rep::_S_max_size; }
+# 724 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      void
+      resize(size_type __n, _CharT __c);
+# 737 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      void
+      resize(size_type __n)
+      { this->resize(__n, _CharT()); }
+# 757 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      capacity() const
+      { return _M_rep()->_M_capacity; }
+# 778 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      void
+      reserve(size_type __res_arg = 0);
+
+
+
+
+      void
+      clear()
+      { _M_mutate(0, this->size(), 0); }
+
+
+
+
+
+      bool
+      empty() const
+      { return this->size() == 0; }
+# 807 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      const_reference
+      operator[] (size_type __pos) const
+      {
+ ;
+ return _M_data()[__pos];
+      }
+# 824 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      reference
+      operator[](size_type __pos)
+      {
+
+ ;
+
+ ;
+ _M_leak();
+ return _M_data()[__pos];
+      }
+# 845 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range(("basic_string::at"));
+ return _M_data()[__n];
+      }
+# 864 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      reference
+      at(size_type __n)
+      {
+ if (__n >= size())
+   __throw_out_of_range(("basic_string::at"));
+ _M_leak();
+ return _M_data()[__n];
+      }
+
+
+
+
+
+
+
+      basic_string&
+      operator+=(const basic_string& __str)
+      { return this->append(__str); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(const _CharT* __s)
+      { return this->append(__s); }
+
+
+
+
+
+
+      basic_string&
+      operator+=(_CharT __c)
+      {
+ this->push_back(__c);
+ return *this;
+      }
+# 920 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      append(const basic_string& __str);
+# 935 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      append(const basic_string& __str, size_type __pos, size_type __n);
+
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s, size_type __n);
+
+
+
+
+
+
+      basic_string&
+      append(const _CharT* __s)
+      {
+ ;
+ return this->append(__s, traits_type::length(__s));
+      }
+# 967 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      append(size_type __n, _CharT __c);
+# 989 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      template<class _InputIterator>
+        basic_string&
+        append(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_iend(), _M_iend(), __first, __last); }
+
+
+
+
+
+      void
+      push_back(_CharT __c)
+      {
+ const size_type __len = 1 + this->size();
+ if (__len > this->capacity() || _M_rep()->_M_is_shared())
+   this->reserve(__len);
+ traits_type::assign(_M_data()[this->size()], __c);
+ _M_rep()->_M_set_length_and_sharable(__len);
+      }
+
+
+
+
+
+
+      basic_string&
+      assign(const basic_string& __str);
+# 1045 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      assign(const basic_string& __str, size_type __pos, size_type __n)
+      { return this->assign(__str._M_data()
+       + __str._M_check(__pos, "basic_string::assign"),
+       __str._M_limit(__pos, __n)); }
+# 1061 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s, size_type __n);
+# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      assign(const _CharT* __s)
+      {
+ ;
+ return this->assign(__s, traits_type::length(__s));
+      }
+# 1089 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      assign(size_type __n, _CharT __c)
+      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
+# 1101 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      template<class _InputIterator>
+        basic_string&
+        assign(_InputIterator __first, _InputIterator __last)
+        { return this->replace(_M_ibegin(), _M_iend(), __first, __last); }
+# 1129 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      void
+      insert(iterator __p, size_type __n, _CharT __c)
+      { this->replace(__p, __p, __n, __c); }
+# 1144 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      template<class _InputIterator>
+        void
+        insert(iterator __p, _InputIterator __beg, _InputIterator __end)
+        { this->replace(__p, __p, __beg, __end); }
+# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str)
+      { return this->insert(__pos1, __str, size_type(0), __str.size()); }
+# 1197 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos1, const basic_string& __str,
+      size_type __pos2, size_type __n)
+      { return this->insert(__pos1, __str._M_data()
+       + __str._M_check(__pos2, "basic_string::insert"),
+       __str._M_limit(__pos2, __n)); }
+# 1220 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s, size_type __n);
+# 1238 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, const _CharT* __s)
+      {
+ ;
+ return this->insert(__pos, __s, traits_type::length(__s));
+      }
+# 1261 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      insert(size_type __pos, size_type __n, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
+         size_type(0), __n, __c); }
+# 1278 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      iterator
+      insert(iterator __p, _CharT __c)
+      {
+ ;
+ const size_type __pos = __p - _M_ibegin();
+ _M_replace_aux(__pos, size_type(0), size_type(1), __c);
+ _M_rep()->_M_set_leaked();
+ return iterator(_M_data() + __pos);
+      }
+# 1302 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      erase(size_type __pos = 0, size_type __n = npos)
+      {
+ _M_mutate(_M_check(__pos, "basic_string::erase"),
+    _M_limit(__pos, __n), size_type(0));
+ return *this;
+      }
+# 1318 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      iterator
+      erase(iterator __position)
+      {
+
+                               ;
+ const size_type __pos = __position - _M_ibegin();
+ _M_mutate(__pos, size_type(1), size_type(0));
+ _M_rep()->_M_set_leaked();
+ return iterator(_M_data() + __pos);
+      }
+# 1338 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      iterator
+      erase(iterator __first, iterator __last);
+# 1357 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n, const basic_string& __str)
+      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
+# 1379 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2)
+      { return this->replace(__pos1, __n1, __str._M_data()
+        + __str._M_check(__pos2, "basic_string::replace"),
+        __str._M_limit(__pos2, __n2)); }
+# 1403 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2);
+# 1422 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, const _CharT* __s)
+      {
+ ;
+ return this->replace(__pos, __n1, __s, traits_type::length(__s));
+      }
+# 1445 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
+      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
+         _M_limit(__pos, __n1), __n2, __c); }
+# 1463 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(iterator __i1, iterator __i2, const basic_string& __str)
+      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
+# 1481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n)
+      {
+
+                          ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n);
+      }
+# 1502 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(iterator __i1, iterator __i2, const _CharT* __s)
+      {
+ ;
+ return this->replace(__i1, __i2, __s, traits_type::length(__s));
+      }
+# 1523 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string&
+      replace(iterator __i1, iterator __i2, size_type __n, _CharT __c)
+      {
+
+                          ;
+ return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c);
+      }
+# 1545 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      template<class _InputIterator>
+        basic_string&
+        replace(iterator __i1, iterator __i2,
+  _InputIterator __k1, _InputIterator __k2)
+        {
+  
+                            ;
+   ;
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral());
+ }
+
+
+
+      basic_string&
+      replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2)
+      {
+
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(iterator __i1, iterator __i2,
+       const _CharT* __k1, const _CharT* __k2)
+      {
+
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1, __k2 - __k1);
+      }
+
+      basic_string&
+      replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2)
+      {
+
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+
+      basic_string&
+      replace(iterator __i1, iterator __i2,
+       const_iterator __k1, const_iterator __k2)
+      {
+
+                          ;
+ ;
+ return this->replace(__i1 - _M_ibegin(), __i2 - __i1,
+        __k1.base(), __k2 - __k1);
+      }
+# 1620 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+    private:
+      template<class _Integer>
+ basic_string&
+ _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n,
+       _Integer __val, __true_type)
+        { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); }
+
+      template<class _InputIterator>
+ basic_string&
+ _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
+       _InputIterator __k2, __false_type);
+
+      basic_string&
+      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+       _CharT __c);
+
+      basic_string&
+      _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
+        size_type __n2);
+
+
+
+      template<class _InIterator>
+        static _CharT*
+        _S_construct_aux(_InIterator __beg, _InIterator __end,
+    const _Alloc& __a, __false_type)
+ {
+          typedef typename iterator_traits<_InIterator>::iterator_category _Tag;
+          return _S_construct(__beg, __end, __a, _Tag());
+ }
+
+
+
+      template<class _Integer>
+        static _CharT*
+        _S_construct_aux(_Integer __beg, _Integer __end,
+    const _Alloc& __a, __true_type)
+        { return _S_construct_aux_2(static_cast<size_type>(__beg),
+        __end, __a); }
+
+      static _CharT*
+      _S_construct_aux_2(size_type __req, _CharT __c, const _Alloc& __a)
+      { return _S_construct(__req, __c, __a); }
+
+      template<class _InIterator>
+        static _CharT*
+        _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a)
+ {
+   typedef typename std::__is_integer<_InIterator>::__type _Integral;
+   return _S_construct_aux(__beg, __end, __a, _Integral());
+        }
+
+
+      template<class _InIterator>
+        static _CharT*
+         _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+        input_iterator_tag);
+
+
+
+      template<class _FwdIterator>
+        static _CharT*
+        _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a,
+       forward_iterator_tag);
+
+      static _CharT*
+      _S_construct(size_type __req, _CharT __c, const _Alloc& __a);
+
+    public:
+# 1701 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
+# 1711 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      void
+      swap(basic_string& __s);
+# 1721 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      const _CharT*
+      c_str() const
+      { return _M_data(); }
+
+
+
+
+
+
+
+      const _CharT*
+      data() const
+      { return _M_data(); }
+
+
+
+
+      allocator_type
+      get_allocator() const
+      { return _M_dataplus; }
+# 1753 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos, size_type __n) const;
+# 1766 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find(const basic_string& __str, size_type __pos = 0) const
+      { return this->find(__str.data(), __pos, __str.size()); }
+# 1780 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find(__s, __pos, traits_type::length(__s));
+      }
+# 1797 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find(_CharT __c, size_type __pos = 0) const;
+# 1810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      rfind(const basic_string& __str, size_type __pos = npos) const
+      { return this->rfind(__str.data(), __pos, __str.size()); }
+# 1825 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos, size_type __n) const;
+# 1838 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      rfind(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->rfind(__s, __pos, traits_type::length(__s));
+      }
+# 1855 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      rfind(_CharT __c, size_type __pos = npos) const;
+# 1868 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_of(const basic_string& __str, size_type __pos = 0) const
+      { return this->find_first_of(__str.data(), __pos, __str.size()); }
+# 1883 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const;
+# 1896 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_of(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find_first_of(__s, __pos, traits_type::length(__s));
+      }
+# 1915 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_of(_CharT __c, size_type __pos = 0) const
+      { return this->find(__c, __pos); }
+# 1929 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_of(const basic_string& __str, size_type __pos = npos) const
+      { return this->find_last_of(__str.data(), __pos, __str.size()); }
+# 1944 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const;
+# 1957 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_of(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->find_last_of(__s, __pos, traits_type::length(__s));
+      }
+# 1976 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_of(_CharT __c, size_type __pos = npos) const
+      { return this->rfind(__c, __pos); }
+# 1990 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
+      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
+# 2005 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos,
+   size_type __n) const;
+# 2019 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
+      {
+ ;
+ return this->find_first_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2036 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_first_not_of(_CharT __c, size_type __pos = 0) const;
+# 2049 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
+      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
+# 2065 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos,
+         size_type __n) const;
+# 2078 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
+      {
+ ;
+ return this->find_last_not_of(__s, __pos, traits_type::length(__s));
+      }
+# 2095 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      size_type
+      find_last_not_of(_CharT __c, size_type __pos = npos) const;
+# 2110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      basic_string
+      substr(size_type __pos = 0, size_type __n = npos) const
+      { return basic_string(*this,
+       _M_check(__pos, "basic_string::substr"), __n); }
+# 2128 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      int
+      compare(const basic_string& __str) const
+      {
+ const size_type __size = this->size();
+ const size_type __osize = __str.size();
+ const size_type __len = std::min(__size, __osize);
+
+ int __r = traits_type::compare(_M_data(), __str.data(), __len);
+ if (!__r)
+   __r = _S_compare(__size, __osize);
+ return __r;
+      }
+# 2158 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n, const basic_string& __str) const;
+# 2182 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      int
+      compare(size_type __pos1, size_type __n1, const basic_string& __str,
+       size_type __pos2, size_type __n2) const;
+# 2200 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      int
+      compare(const _CharT* __s) const;
+# 2223 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s) const;
+# 2248 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+      int
+      compare(size_type __pos, size_type __n1, const _CharT* __s,
+       size_type __n2) const;
+  };
+# 2260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT,_Traits,_Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs);
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+      const _CharT* __rhs)
+    {
+      basic_string<_CharT, _Traits, _Alloc> __str(__lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_string<_CharT, _Traits, _Alloc>
+    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str(__lhs);
+      __str.append(__size_type(1), __rhs);
+      return __str;
+    }
+# 2331 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+
+  template<typename _CharT>
+    inline
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
+    operator==(const basic_string<_CharT>& __lhs,
+        const basic_string<_CharT>& __rhs)
+    { return (__lhs.size() == __rhs.size()
+       && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
+          __lhs.size())); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) == 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) == 0; }
+# 2377 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return !(__lhs == __rhs); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return !(__lhs == __rhs); }
+# 2414 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) < 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) > 0; }
+# 2451 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+       const _CharT* __rhs)
+    { return __lhs.compare(__rhs) > 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) < 0; }
+# 2488 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) <= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator<=(const _CharT* __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) >= 0; }
+# 2525 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
+        const _CharT* __rhs)
+    { return __lhs.compare(__rhs) >= 0; }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline bool
+    operator>=(const _CharT* __lhs,
+      const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { return __rhs.compare(__lhs) <= 0; }
+# 2562 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline void
+    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
+  basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    { __lhs.swap(__rhs); }
+# 2579 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is,
+        basic_string<_CharT, _Traits, _Alloc>& __str);
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
+# 2597 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os,
+        const basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+
+
+      return __ostream_insert(__os, __str.data(), __str.size());
+    }
+# 2620 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
+# 2638 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.h" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    inline basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __is,
+     basic_string<_CharT, _Traits, _Alloc>& __str)
+    { return getline(__is, __str, __is.widen('\n')); }
+
+  template<>
+    basic_istream<char>&
+    getline(basic_istream<char>& __in, basic_string<char>& __str,
+     char __delim);
+
+
+  template<>
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+     wchar_t __delim);
+
+
+}
+# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 1 3
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3
+       
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4;
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const _CharT
+    basic_string<_CharT, _Traits, _Alloc>::
+    _Rep::_S_terminal = _CharT();
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::npos;
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[
+    (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) /
+      sizeof(size_type)];
+
+
+
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InIterator>
+      _CharT*
+      basic_string<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+     input_iterator_tag)
+      {
+
+ if (__beg == __end && __a == _Alloc())
+   return _S_empty_rep()._M_refdata();
+
+
+ _CharT __buf[128];
+ size_type __len = 0;
+ while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT))
+   {
+     __buf[__len++] = *__beg;
+     ++__beg;
+   }
+ _Rep* __r = _Rep::_S_create(__len, size_type(0), __a);
+ _M_copy(__r->_M_refdata(), __buf, __len);
+ try
+   {
+     while (__beg != __end)
+       {
+  if (__len == __r->_M_capacity)
+    {
+
+      _Rep* __another = _Rep::_S_create(__len + 1, __len, __a);
+      _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len);
+      __r->_M_destroy(__a);
+      __r = __another;
+    }
+  __r->_M_refdata()[__len++] = *__beg;
+  ++__beg;
+       }
+   }
+ catch(...)
+   {
+     __r->_M_destroy(__a);
+     throw;
+   }
+ __r->_M_set_length_and_sharable(__len);
+ return __r->_M_refdata();
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template <typename _InIterator>
+      _CharT*
+      basic_string<_CharT, _Traits, _Alloc>::
+      _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a,
+     forward_iterator_tag)
+      {
+
+ if (__beg == __end && __a == _Alloc())
+   return _S_empty_rep()._M_refdata();
+
+
+ if (__gnu_cxx::__is_null_pointer(__beg) && __beg != __end)
+   __throw_logic_error(("basic_string::_S_construct NULL not valid"));
+
+ const size_type __dnew = static_cast<size_type>(std::distance(__beg,
+              __end));
+
+ _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a);
+ try
+   { _S_copy_chars(__r->_M_refdata(), __beg, __end); }
+ catch(...)
+   {
+     __r->_M_destroy(__a);
+     throw;
+   }
+ __r->_M_set_length_and_sharable(__dnew);
+ return __r->_M_refdata();
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    basic_string<_CharT, _Traits, _Alloc>::
+    _S_construct(size_type __n, _CharT __c, const _Alloc& __a)
+    {
+
+      if (__n == 0 && __a == _Alloc())
+ return _S_empty_rep()._M_refdata();
+
+
+      _Rep* __r = _Rep::_S_create(__n, size_type(0), __a);
+      if (__n)
+ _M_assign(__r->_M_refdata(), __n, __c);
+
+      __r->_M_set_length_and_sharable(__n);
+      return __r->_M_refdata();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str)
+    : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()),
+       __str.get_allocator()),
+    __str.get_allocator())
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _Alloc& __a)
+    : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a)
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str, size_type __pos, size_type __n)
+    : _M_dataplus(_S_construct(__str._M_data()
+          + __str._M_check(__pos,
+      "basic_string::basic_string"),
+          __str._M_data() + __str._M_limit(__pos, __n)
+          + __pos, _Alloc()), _Alloc())
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const basic_string& __str, size_type __pos,
+   size_type __n, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__str._M_data()
+          + __str._M_check(__pos,
+      "basic_string::basic_string"),
+          __str._M_data() + __str._M_limit(__pos, __n)
+          + __pos, __a), __a)
+    { }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _CharT* __s, size_type __n, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__s, __s + __n, __a), __a)
+    { }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(const _CharT* __s, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) :
+          __s + npos, __a), __a)
+    { }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(size_type __n, _CharT __c, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__n, __c, __a), __a)
+    { }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+    basic_string<_CharT, _Traits, _Alloc>::
+    basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a)
+    : _M_dataplus(_S_construct(__beg, __end, __a), __a)
+    { }
+# 240 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    assign(const basic_string& __str)
+    {
+      if (_M_rep() != __str._M_rep())
+ {
+
+   const allocator_type __a = this->get_allocator();
+   _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator());
+   _M_rep()->_M_dispose(__a);
+   _M_data(__tmp);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    assign(const _CharT* __s, size_type __n)
+    {
+      ;
+      _M_check_length(this->size(), __n, "basic_string::assign");
+      if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+ return _M_replace_safe(size_type(0), this->size(), __s, __n);
+      else
+ {
+
+   const size_type __pos = __s - _M_data();
+   if (__pos >= __n)
+     _M_copy(_M_data(), __s, __n);
+   else if (__pos)
+     _M_move(_M_data(), __s, __n);
+   _M_rep()->_M_set_length_and_sharable(__n);
+   return *this;
+ }
+     }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(size_type __n, _CharT __c)
+    {
+      if (__n)
+ {
+   _M_check_length(size_type(0), __n, "basic_string::append");
+   const size_type __len = __n + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     this->reserve(__len);
+   _M_assign(_M_data() + this->size(), __n, __c);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const _CharT* __s, size_type __n)
+    {
+      ;
+      if (__n)
+ {
+   _M_check_length(size_type(0), __n, "basic_string::append");
+   const size_type __len = __n + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     {
+       if (_M_disjunct(__s))
+  this->reserve(__len);
+       else
+  {
+    const size_type __off = __s - _M_data();
+    this->reserve(__len);
+    __s = _M_data() + __off;
+  }
+     }
+   _M_copy(_M_data() + this->size(), __s, __n);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str)
+    {
+      const size_type __size = __str.size();
+      if (__size)
+ {
+   const size_type __len = __size + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     this->reserve(__len);
+   _M_copy(_M_data() + this->size(), __str._M_data(), __size);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    append(const basic_string& __str, size_type __pos, size_type __n)
+    {
+      __str._M_check(__pos, "basic_string::append");
+      __n = __str._M_limit(__pos, __n);
+      if (__n)
+ {
+   const size_type __len = __n + this->size();
+   if (__len > this->capacity() || _M_rep()->_M_is_shared())
+     this->reserve(__len);
+   _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n);
+   _M_rep()->_M_set_length_and_sharable(__len);
+ }
+      return *this;
+    }
+
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     basic_string<_CharT, _Traits, _Alloc>&
+     basic_string<_CharT, _Traits, _Alloc>::
+     insert(size_type __pos, const _CharT* __s, size_type __n)
+     {
+       ;
+       _M_check(__pos, "basic_string::insert");
+       _M_check_length(size_type(0), __n, "basic_string::insert");
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+         return _M_replace_safe(__pos, size_type(0), __s, __n);
+       else
+         {
+
+           const size_type __off = __s - _M_data();
+           _M_mutate(__pos, 0, __n);
+           __s = _M_data() + __off;
+           _CharT* __p = _M_data() + __pos;
+           if (__s + __n <= __p)
+             _M_copy(__p, __s, __n);
+           else if (__s >= __p)
+             _M_copy(__p, __s + __n, __n);
+           else
+             {
+        const size_type __nleft = __p - __s;
+               _M_copy(__p, __s, __nleft);
+               _M_copy(__p + __nleft, __p + __n, __n - __nleft);
+             }
+           return *this;
+         }
+     }
+
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     typename basic_string<_CharT, _Traits, _Alloc>::iterator
+     basic_string<_CharT, _Traits, _Alloc>::
+     erase(iterator __first, iterator __last)
+     {
+      
+                           ;
+
+
+
+
+       const size_type __size = __last - __first;
+       if (__size)
+  {
+    const size_type __pos = __first - _M_ibegin();
+    _M_mutate(__pos, __size, size_type(0));
+    _M_rep()->_M_set_leaked();
+    return iterator(_M_data() + __pos);
+  }
+       else
+  return __first;
+     }
+
+   template<typename _CharT, typename _Traits, typename _Alloc>
+     basic_string<_CharT, _Traits, _Alloc>&
+     basic_string<_CharT, _Traits, _Alloc>::
+     replace(size_type __pos, size_type __n1, const _CharT* __s,
+      size_type __n2)
+     {
+       ;
+       _M_check(__pos, "basic_string::replace");
+       __n1 = _M_limit(__pos, __n1);
+       _M_check_length(__n1, __n2, "basic_string::replace");
+       bool __left;
+       if (_M_disjunct(__s) || _M_rep()->_M_is_shared())
+         return _M_replace_safe(__pos, __n1, __s, __n2);
+       else if ((__left = __s + __n2 <= _M_data() + __pos)
+  || _M_data() + __pos + __n1 <= __s)
+  {
+
+    size_type __off = __s - _M_data();
+    __left ? __off : (__off += __n2 - __n1);
+    _M_mutate(__pos, __n1, __n2);
+    _M_copy(_M_data() + __pos, _M_data() + __off, __n2);
+    return *this;
+  }
+       else
+  {
+
+    const basic_string __tmp(__s, __n2);
+    return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2);
+  }
+     }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _M_destroy(const _Alloc& __a) throw ()
+    {
+      const size_type __size = sizeof(_Rep_base) +
+                        (this->_M_capacity + 1) * sizeof(_CharT);
+      _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_leak_hard()
+    {
+
+      if (_M_rep() == &_S_empty_rep())
+ return;
+
+      if (_M_rep()->_M_is_shared())
+ _M_mutate(0, 0, 0);
+      _M_rep()->_M_set_leaked();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_mutate(size_type __pos, size_type __len1, size_type __len2)
+    {
+      const size_type __old_size = this->size();
+      const size_type __new_size = __old_size + __len2 - __len1;
+      const size_type __how_much = __old_size - __pos - __len1;
+
+      if (__new_size > this->capacity() || _M_rep()->_M_is_shared())
+ {
+
+   const allocator_type __a = get_allocator();
+   _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a);
+
+   if (__pos)
+     _M_copy(__r->_M_refdata(), _M_data(), __pos);
+   if (__how_much)
+     _M_copy(__r->_M_refdata() + __pos + __len2,
+      _M_data() + __pos + __len1, __how_much);
+
+   _M_rep()->_M_dispose(__a);
+   _M_data(__r->_M_refdata());
+ }
+      else if (__how_much && __len1 != __len2)
+ {
+
+   _M_move(_M_data() + __pos + __len2,
+    _M_data() + __pos + __len1, __how_much);
+ }
+      _M_rep()->_M_set_length_and_sharable(__new_size);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    reserve(size_type __res)
+    {
+      if (__res != this->capacity() || _M_rep()->_M_is_shared())
+        {
+
+   if (__res < this->size())
+     __res = this->size();
+   const allocator_type __a = get_allocator();
+   _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size());
+   _M_rep()->_M_dispose(__a);
+   _M_data(__tmp);
+        }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    swap(basic_string& __s)
+    {
+      if (_M_rep()->_M_is_leaked())
+ _M_rep()->_M_set_sharable();
+      if (__s._M_rep()->_M_is_leaked())
+ __s._M_rep()->_M_set_sharable();
+      if (this->get_allocator() == __s.get_allocator())
+ {
+   _CharT* __tmp = _M_data();
+   _M_data(__s._M_data());
+   __s._M_data(__tmp);
+ }
+
+      else
+ {
+   const basic_string __tmp1(_M_ibegin(), _M_iend(),
+        __s.get_allocator());
+   const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(),
+        this->get_allocator());
+   *this = __tmp2;
+   __s = __tmp1;
+ }
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::_Rep*
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _S_create(size_type __capacity, size_type __old_capacity,
+       const _Alloc& __alloc)
+    {
+
+
+      if (__capacity > _S_max_size)
+ __throw_length_error(("basic_string::_S_create"));
+# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_string.tcc" 3
+      const size_type __pagesize = 4096;
+      const size_type __malloc_header_size = 4 * sizeof(void*);
+
+
+
+
+
+
+
+      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
+ __capacity = 2 * __old_capacity;
+
+
+
+
+      size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
+
+      const size_type __adj_size = __size + __malloc_header_size;
+      if (__adj_size > __pagesize && __capacity > __old_capacity)
+ {
+   const size_type __extra = __pagesize - __adj_size % __pagesize;
+   __capacity += __extra / sizeof(_CharT);
+
+   if (__capacity > _S_max_size)
+     __capacity = _S_max_size;
+   __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep);
+ }
+
+
+
+      void* __place = _Raw_bytes_alloc(__alloc).allocate(__size);
+      _Rep *__p = new (__place) _Rep;
+      __p->_M_capacity = __capacity;
+
+
+
+
+
+
+
+      __p->_M_set_sharable();
+      return __p;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    _CharT*
+    basic_string<_CharT, _Traits, _Alloc>::_Rep::
+    _M_clone(const _Alloc& __alloc, size_type __res)
+    {
+
+      const size_type __requested_cap = this->_M_length + __res;
+      _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity,
+      __alloc);
+      if (this->_M_length)
+ _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length);
+
+      __r->_M_set_length_and_sharable(this->_M_length);
+      return __r->_M_refdata();
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    void
+    basic_string<_CharT, _Traits, _Alloc>::
+    resize(size_type __n, _CharT __c)
+    {
+      const size_type __size = this->size();
+      _M_check_length(__size, __n, "basic_string::resize");
+      if (__size < __n)
+ this->append(__n - __size, __c);
+      else if (__n < __size)
+ this->erase(__n);
+
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    template<typename _InputIterator>
+      basic_string<_CharT, _Traits, _Alloc>&
+      basic_string<_CharT, _Traits, _Alloc>::
+      _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1,
+     _InputIterator __k2, __false_type)
+      {
+ const basic_string __s(__k1, __k2);
+ const size_type __n1 = __i2 - __i1;
+ _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch");
+ return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(),
+          __s.size());
+      }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
+     _CharT __c)
+    {
+      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+ _M_assign(_M_data() + __pos1, __n2, __c);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>&
+    basic_string<_CharT, _Traits, _Alloc>::
+    _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s,
+      size_type __n2)
+    {
+      _M_mutate(__pos1, __n1, __n2);
+      if (__n2)
+ _M_copy(_M_data() + __pos1, __s, __n2);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(const _CharT* __lhs,
+       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      ;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      const __size_type __len = _Traits::length(__lhs);
+      __string_type __str;
+      __str.reserve(__len + __rhs.size());
+      __str.append(__lhs, __len);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_string<_CharT, _Traits, _Alloc>
+    operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs)
+    {
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+      __string_type __str;
+      const __size_type __len = __rhs.size();
+      __str.reserve(__len + 1);
+      __str.append(__size_type(1), __lhs);
+      __str.append(__rhs);
+      return __str;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    copy(_CharT* __s, size_type __n, size_type __pos) const
+    {
+      _M_check(__pos, "basic_string::copy");
+      __n = _M_limit(__pos, __n);
+      ;
+      if (__n)
+ _M_copy(__s, _M_data() + __pos, __n);
+
+      return __n;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      const size_type __size = this->size();
+      const _CharT* __data = _M_data();
+
+      if (__n == 0)
+ return __pos <= __size ? __pos : npos;
+
+      if (__n <= __size)
+ {
+   for (; __pos <= __size - __n; ++__pos)
+     if (traits_type::eq(__data[__pos], __s[0])
+  && traits_type::compare(__data + __pos + 1,
+     __s + 1, __n - 1) == 0)
+       return __pos;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find(_CharT __c, size_type __pos) const
+    {
+      size_type __ret = npos;
+      const size_type __size = this->size();
+      if (__pos < __size)
+ {
+   const _CharT* __data = _M_data();
+   const size_type __n = __size - __pos;
+   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
+   if (__p)
+     __ret = __p - __data;
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      const size_type __size = this->size();
+      if (__n <= __size)
+ {
+   __pos = std::min(size_type(__size - __n), __pos);
+   const _CharT* __data = _M_data();
+   do
+     {
+       if (traits_type::compare(__data + __pos, __s, __n) == 0)
+  return __pos;
+     }
+   while (__pos-- > 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    rfind(_CharT __c, size_type __pos) const
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   for (++__size; __size-- > 0; )
+     if (traits_type::eq(_M_data()[__size], __c))
+       return __size;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      for (; __n && __pos < this->size(); ++__pos)
+ {
+   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
+   if (__p)
+     return __pos;
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      size_type __size = this->size();
+      if (__size && __n)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size-- != 0);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::find(__s, __n, _M_data()[__pos]))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_first_not_of(_CharT __c, size_type __pos) const
+    {
+      for (; __pos < this->size(); ++__pos)
+ if (!traits_type::eq(_M_data()[__pos], __c))
+   return __pos;
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
+    {
+      ;
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::find(__s, __n, _M_data()[__size]))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    typename basic_string<_CharT, _Traits, _Alloc>::size_type
+    basic_string<_CharT, _Traits, _Alloc>::
+    find_last_not_of(_CharT __c, size_type __pos) const
+    {
+      size_type __size = this->size();
+      if (__size)
+ {
+   if (--__size > __pos)
+     __size = __pos;
+   do
+     {
+       if (!traits_type::eq(_M_data()[__size], __c))
+  return __size;
+     }
+   while (__size--);
+ }
+      return npos;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n, const basic_string& __str) const
+    {
+      _M_check(__pos, "basic_string::compare");
+      __n = _M_limit(__pos, __n);
+      const size_type __osize = __str.size();
+      const size_type __len = std::min(__n, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
+      if (!__r)
+ __r = _S_compare(__n, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(size_type __pos1, size_type __n1, const basic_string& __str,
+     size_type __pos2, size_type __n2) const
+    {
+      _M_check(__pos1, "basic_string::compare");
+      __str._M_check(__pos2, "basic_string::compare");
+      __n1 = _M_limit(__pos1, __n1);
+      __n2 = __str._M_limit(__pos2, __n2);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos1,
+         __str.data() + __pos2, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string<_CharT, _Traits, _Alloc>::
+    compare(const _CharT* __s) const
+    {
+      ;
+      const size_type __size = this->size();
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__size, __osize);
+      int __r = traits_type::compare(_M_data(), __s, __len);
+      if (!__r)
+ __r = _S_compare(__size, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __osize = traits_type::length(__s);
+      const size_type __len = std::min(__n1, __osize);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __osize);
+      return __r;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    int
+    basic_string <_CharT, _Traits, _Alloc>::
+    compare(size_type __pos, size_type __n1, const _CharT* __s,
+     size_type __n2) const
+    {
+      ;
+      _M_check(__pos, "basic_string::compare");
+      __n1 = _M_limit(__pos, __n1);
+      const size_type __len = std::min(__n1, __n2);
+      int __r = traits_type::compare(_M_data() + __pos, __s, __len);
+      if (!__r)
+ __r = _S_compare(__n1, __n2);
+      return __r;
+    }
+
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in,
+        basic_string<_CharT, _Traits, _Alloc>& __str)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+      typedef ctype<_CharT> __ctype_type;
+      typedef typename __ctype_type::ctype_base __ctype_base;
+
+      __size_type __extracted = 0;
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+
+       __str.erase();
+       _CharT __buf[128];
+       __size_type __len = 0;
+       const streamsize __w = __in.width();
+       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
+                                : __str.max_size();
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(__ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    if (__len == sizeof(__buf) / sizeof(_CharT))
+      {
+        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
+        __len = 0;
+      }
+    __buf[__len++] = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+       __str.append(__buf, __len);
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+
+
+
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    basic_istream<_CharT, _Traits>&
+    getline(basic_istream<_CharT, _Traits>& __in,
+     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef typename __istream_type::ios_base __ios_base;
+      typedef typename __istream_type::int_type __int_type;
+      typedef typename __string_type::size_type __size_type;
+
+      __size_type __extracted = 0;
+      const __size_type __n = __str.max_size();
+      typename __ios_base::iostate __err = __ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, true);
+      if (__cerb)
+ {
+   try
+     {
+       __str.erase();
+       const __int_type __idelim = _Traits::to_int_type(__delim);
+       const __int_type __eof = _Traits::eof();
+       __int_type __c = __in.rdbuf()->sgetc();
+
+       while (__extracted < __n
+       && !_Traits::eq_int_type(__c, __eof)
+       && !_Traits::eq_int_type(__c, __idelim))
+  {
+    __str += _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __in.rdbuf()->snextc();
+  }
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= __ios_base::eofbit;
+       else if (_Traits::eq_int_type(__c, __idelim))
+  {
+    ++__extracted;
+    __in.rdbuf()->sbumpc();
+  }
+       else
+  __err |= __ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(__ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     {
+
+
+
+       __in._M_setstate(__ios_base::badbit);
+     }
+ }
+      if (!__extracted)
+ __err |= __ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+
+
+
+
+  extern template class basic_string<char>;
+  extern template
+    basic_istream<char>&
+    operator>>(basic_istream<char>&, string&);
+  extern template
+    basic_ostream<char>&
+    operator<<(basic_ostream<char>&, const string&);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&, char);
+  extern template
+    basic_istream<char>&
+    getline(basic_istream<char>&, string&);
+
+
+  extern template class basic_string<wchar_t>;
+  extern template
+    basic_istream<wchar_t>&
+    operator>>(basic_istream<wchar_t>&, wstring&);
+  extern template
+    basic_ostream<wchar_t>&
+    operator<<(basic_ostream<wchar_t>&, const wstring&);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
+  extern template
+    basic_istream<wchar_t>&
+    getline(basic_istream<wchar_t>&, wstring&);
+
+
+
+}
+# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/string" 2 3
+# 61 "/usr/include/qt4/QtCore/qstring.h" 2
+
+
+
+
+typedef std::basic_string<wchar_t> QStdWString;
+# 76 "/usr/include/qt4/QtCore/qstring.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QCharRef;
+class QRegExp;
+class QStringList;
+class QTextCodec;
+class QLatin1String;
+class QStringRef;
+template <typename T> class QVector;
+
+class QString
+{
+public:
+    inline QString();
+    QString(const QChar *unicode, int size);
+    QString(QChar c);
+    QString(int size, QChar c);
+    inline QString(const QLatin1String &latin1);
+    inline QString(const QString &);
+    inline ~QString();
+    QString &operator=(QChar c);
+    QString &operator=(const QString &);
+    inline QString &operator=(const QLatin1String &);
+
+    inline int size() const { return d->size; }
+    inline int count() const { return d->size; }
+    inline int length() const;
+    inline bool isEmpty() const;
+    void resize(int size);
+
+    QString &fill(QChar c, int size = -1);
+    void truncate(int pos);
+    void chop(int n);
+
+    int capacity() const;
+    inline void reserve(int size);
+    inline void squeeze() { if (d->size < d->alloc || d->ref != 1) realloc(); d->capacity = 0;}
+
+    inline const QChar *unicode() const;
+    inline QChar *data();
+    inline const QChar *data() const;
+    inline const QChar *constData() const;
+
+    inline void detach();
+    inline bool isDetached() const;
+    void clear();
+
+    inline const QChar at(int i) const;
+    const QChar operator[](int i) const;
+    QCharRef operator[](int i);
+    const QChar operator[](uint i) const;
+    QCharRef operator[](uint i);
+
+    QString arg(qlonglong a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(qulonglong a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(long a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(ulong a, int fieldwidth=0, int base=10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(int a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(uint a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(short a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(ushort a, int fieldWidth = 0, int base = 10,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(char a, int fieldWidth = 0,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(QChar a, int fieldWidth = 0,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a, int fieldWidth = 0,
+                const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6,
+                const QString &a7) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6,
+                const QString &a7, const QString &a8) const __attribute__ ((warn_unused_result));
+    QString arg(const QString &a1, const QString &a2, const QString &a3,
+                const QString &a4, const QString &a5, const QString &a6,
+                const QString &a7, const QString &a8, const QString &a9) const __attribute__ ((warn_unused_result));
+
+    QString &vsprintf(const char *format, va_list ap)
+
+        __attribute__ ((format (printf, 2, 0)))
+
+        ;
+    QString &sprintf(const char *format, ...)
+
+        __attribute__ ((format (printf, 2, 3)))
+
+        ;
+
+    int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+
+    int indexOf(const QRegExp &, int from = 0) const;
+    int lastIndexOf(const QRegExp &, int from = -1) const;
+    inline QBool contains(const QRegExp &rx) const { return QBool(indexOf(rx) != -1); }
+    int count(const QRegExp &) const;
+
+    int indexOf(QRegExp &, int from = 0) const;
+    int lastIndexOf(QRegExp &, int from = -1) const;
+    inline QBool contains(QRegExp &rx) const { return QBool(indexOf(rx) != -1); }
+
+
+    enum SectionFlag {
+        SectionDefault = 0x00,
+        SectionSkipEmpty = 0x01,
+        SectionIncludeLeadingSep = 0x02,
+        SectionIncludeTrailingSep = 0x04,
+        SectionCaseInsensitiveSeps = 0x08
+    };
+    typedef QFlags<SectionFlag> SectionFlags;
+
+    QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
+    QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const;
+
+    QString section(const QRegExp &reg, int start, int end = -1, SectionFlags flags = SectionDefault) const;
+
+
+    QString left(int n) const __attribute__ ((warn_unused_result));
+    QString right(int n) const __attribute__ ((warn_unused_result));
+    QString mid(int position, int n = -1) const __attribute__ ((warn_unused_result));
+    QStringRef leftRef(int n) const __attribute__ ((warn_unused_result));
+    QStringRef rightRef(int n) const __attribute__ ((warn_unused_result));
+    QStringRef midRef(int position, int n = -1) const __attribute__ ((warn_unused_result));
+
+    bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result));
+    QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result));
+
+    QString toLower() const __attribute__ ((warn_unused_result));
+    QString toUpper() const __attribute__ ((warn_unused_result));
+    QString toCaseFolded() const __attribute__ ((warn_unused_result));
+
+    QString trimmed() const __attribute__ ((warn_unused_result));
+    QString simplified() const __attribute__ ((warn_unused_result));
+
+    QString &insert(int i, QChar c);
+    QString &insert(int i, const QChar *uc, int len);
+    inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); }
+    QString &insert(int i, const QLatin1String &s);
+    QString &append(QChar c);
+    QString &append(const QString &s);
+    QString &append(const QStringRef &s);
+    QString &append(const QLatin1String &s);
+    inline QString &prepend(QChar c) { return insert(0, c); }
+    inline QString &prepend(const QString &s) { return insert(0, s); }
+    inline QString &prepend(const QLatin1String &s) { return insert(0, s); }
+
+    inline QString &operator+=(QChar c) {
+        if (d->ref != 1 || d->size + 1 > d->alloc)
+            realloc(grow(d->size + 1));
+        d->data[d->size++] = c.unicode();
+        d->data[d->size] = '\0';
+        return *this;
+    }
+
+    inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); }
+    inline QString &operator+=(const QString &s) { return append(s); }
+    inline QString &operator+=(const QStringRef &s) { return append(s); }
+    inline QString &operator+=(const QLatin1String &s) { return append(s); }
+
+    QString &remove(int i, int len);
+    QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(int i, int len, QChar after);
+    QString &replace(int i, int len, const QChar *s, int slen);
+    QString &replace(int i, int len, const QString &after);
+    QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(const QString &before, const QString &after,
+                     Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QString &replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+
+    QString &replace(const QRegExp &rx, const QString &after);
+    inline QString &remove(const QRegExp &rx)
+    { return replace(rx, QString()); }
+
+
+    enum SplitBehavior { KeepEmptyParts, SkipEmptyParts };
+
+    QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts,
+                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result));
+    QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts,
+                      Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result));
+
+    QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((warn_unused_result));
+
+
+    enum NormalizationForm {
+        NormalizationForm_D,
+        NormalizationForm_C,
+        NormalizationForm_KD,
+        NormalizationForm_KC
+    };
+    QString normalized(NormalizationForm mode) const __attribute__ ((warn_unused_result));
+    QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const __attribute__ ((warn_unused_result));
+
+    QString repeated(int times) const;
+
+    const ushort *utf16() const;
+
+    QByteArray toAscii() const __attribute__ ((warn_unused_result));
+    QByteArray toLatin1() const __attribute__ ((warn_unused_result));
+    QByteArray toUtf8() const __attribute__ ((warn_unused_result));
+    QByteArray toLocal8Bit() const __attribute__ ((warn_unused_result));
+    QVector<uint> toUcs4() const __attribute__ ((warn_unused_result));
+
+    static QString fromAscii(const char *, int size = -1);
+    static QString fromLatin1(const char *, int size = -1);
+    static QString fromUtf8(const char *, int size = -1);
+    static QString fromLocal8Bit(const char *, int size = -1);
+    static QString fromUtf16(const ushort *, int size = -1);
+    static QString fromUcs4(const uint *, int size = -1);
+    static QString fromRawData(const QChar *, int size);
+
+    int toWCharArray(wchar_t *array) const;
+    static QString fromWCharArray(const wchar_t *, int size = -1);
+
+    QString &setUnicode(const QChar *unicode, int size);
+    inline QString &setUtf16(const ushort *utf16, int size);
+
+
+    int compare(const QString &s) const;
+    int compare(const QString &s, Qt::CaseSensitivity cs) const;
+
+    int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+
+    static inline int compare(const QString &s1, const QString &s2)
+    { return s1.compare(s2); }
+    static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs)
+    { return s1.compare(s2, cs); }
+
+    static inline int compare(const QString& s1, const QLatin1String &s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive)
+    { return s1.compare(s2, cs); }
+    static inline int compare(const QLatin1String& s1, const QString &s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive)
+    { return -s2.compare(s1, cs); }
+
+    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    static int compare(const QString &s1, const QStringRef &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive);
+
+    int localeAwareCompare(const QString& s) const;
+    static int localeAwareCompare(const QString& s1, const QString& s2)
+    { return s1.localeAwareCompare(s2); }
+
+    int localeAwareCompare(const QStringRef &s) const;
+    static int localeAwareCompare(const QString& s1, const QStringRef& s2);
+
+    short toShort(bool *ok=0, int base=10) const;
+    ushort toUShort(bool *ok=0, int base=10) const;
+    int toInt(bool *ok=0, int base=10) const;
+    uint toUInt(bool *ok=0, int base=10) const;
+    long toLong(bool *ok=0, int base=10) const;
+    ulong toULong(bool *ok=0, int base=10) const;
+    qlonglong toLongLong(bool *ok=0, int base=10) const;
+    qulonglong toULongLong(bool *ok=0, int base=10) const;
+    float toFloat(bool *ok=0) const;
+    double toDouble(bool *ok=0) const;
+
+    QString &setNum(short, int base=10);
+    QString &setNum(ushort, int base=10);
+    QString &setNum(int, int base=10);
+    QString &setNum(uint, int base=10);
+    QString &setNum(long, int base=10);
+    QString &setNum(ulong, int base=10);
+    QString &setNum(qlonglong, int base=10);
+    QString &setNum(qulonglong, int base=10);
+    QString &setNum(float, char f='g', int prec=6);
+    QString &setNum(double, char f='g', int prec=6);
+
+    static QString number(int, int base=10);
+    static QString number(uint, int base=10);
+    static QString number(long, int base=10);
+    static QString number(ulong, int base=10);
+    static QString number(qlonglong, int base=10);
+    static QString number(qulonglong, int base=10);
+    static QString number(double, char f='g', int prec=6);
+
+    bool operator==(const QString &s) const;
+    bool operator<(const QString &s) const;
+    inline bool operator>(const QString &s) const { return s < *this; }
+    inline bool operator!=(const QString &s) const { return !operator==(s); }
+    inline bool operator<=(const QString &s) const { return !operator>(s); }
+    inline bool operator>=(const QString &s) const { return !operator<(s); }
+
+    bool operator==(const QLatin1String &s) const;
+    bool operator<(const QLatin1String &s) const;
+    bool operator>(const QLatin1String &s) const;
+    inline bool operator!=(const QLatin1String &s) const { return !operator==(s); }
+    inline bool operator<=(const QLatin1String &s) const { return !operator>(s); }
+    inline bool operator>=(const QLatin1String &s) const { return !operator<(s); }
+
+
+
+    inline QString(const char *ch) : d(fromAscii_helper(ch))
+    {}
+    inline QString(const QByteArray &a)
+        : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size())))
+    {}
+    inline QString &operator=(const char *ch)
+    { return (*this = fromAscii(ch)); }
+    inline QString &operator=(const QByteArray &a)
+    { return (*this = fromAscii(a.constData(), qstrnlen(a.constData(), a.size()))); }
+    inline QString &operator=(char c)
+    { return (*this = QChar::fromAscii(c)); }
+
+
+    inline QString &prepend(const char *s)
+    { return prepend(QString::fromAscii(s)); }
+    inline QString &prepend(const QByteArray &s)
+    { return prepend(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
+    inline QString &append(const char *s)
+    { return append(QString::fromAscii(s)); }
+    inline QString &append(const QByteArray &s)
+    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
+    inline QString &operator+=(const char *s)
+    { return append(QString::fromAscii(s)); }
+    inline QString &operator+=(const QByteArray &s)
+    { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); }
+    inline QString &operator+=(char c)
+    { return append(QChar::fromAscii(c)); }
+
+    inline bool operator==(const char *s) const;
+    inline bool operator!=(const char *s) const;
+    inline bool operator<(const char *s) const;
+    inline bool operator<=(const char *s2) const;
+    inline bool operator>(const char *s2) const;
+    inline bool operator>=(const char *s2) const;
+
+    inline bool operator==(const QByteArray &s) const;
+    inline bool operator!=(const QByteArray &s) const;
+    inline bool operator<(const QByteArray &s) const
+    { return *this < QString::fromAscii(s.constData(), s.size()); }
+    inline bool operator>(const QByteArray &s) const
+    { return *this > QString::fromAscii(s.constData(), s.size()); }
+    inline bool operator<=(const QByteArray &s) const
+    { return *this <= QString::fromAscii(s.constData(), s.size()); }
+    inline bool operator>=(const QByteArray &s) const
+    { return *this >= QString::fromAscii(s.constData(), s.size()); }
+
+
+    typedef QChar *iterator;
+    typedef const QChar *const_iterator;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    iterator begin();
+    const_iterator begin() const;
+    const_iterator constBegin() const;
+    iterator end();
+    const_iterator end() const;
+    const_iterator constEnd() const;
+
+
+    inline void push_back(QChar c) { append(c); }
+    inline void push_back(const QString &s) { append(s); }
+    inline void push_front(QChar c) { prepend(c); }
+    inline void push_front(const QString &s) { prepend(s); }
+
+
+    static inline QString fromStdString(const std::string &s);
+    inline std::string toStdString() const;
+
+
+
+
+
+    static inline QString fromStdWString(const QStdWString &s);
+    inline QStdWString toStdWString() const;
+
+
+
+
+
+    struct Null { };
+    static const Null null;
+    inline QString(const Null &): d(&shared_null) { d->ref.ref(); }
+    inline QString &operator=(const Null &) { *this = QString(); return *this; }
+    inline bool isNull() const { return d == &shared_null; }
+# 579 "/usr/include/qt4/QtCore/qstring.h"
+    bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; }
+    bool isRightToLeft() const { if (!d->clean) updateProperties(); return d->righttoleft; }
+
+    QString(int size, Qt::Initialization);
+
+private:
+# 594 "/usr/include/qt4/QtCore/qstring.h"
+    struct Data {
+        QBasicAtomicInt ref;
+        int alloc, size;
+        ushort *data;
+        ushort clean : 1;
+        ushort simpletext : 1;
+        ushort righttoleft : 1;
+        ushort asciiCache : 1;
+        ushort capacity : 1;
+        ushort reserved : 11;
+        ushort array[1];
+    };
+    static Data shared_null;
+    static Data shared_empty;
+    Data *d;
+    QString(Data *dd, int ) : d(dd) {}
+
+    static QTextCodec *codecForCStrings;
+
+    static int grow(int);
+    static void free(Data *);
+    void realloc();
+    void realloc(int alloc);
+    void expand(int i);
+    void updateProperties() const;
+    QString multiArg(int numArgs, const QString **args) const;
+    static int compare_helper(const QChar *data1, int length1,
+                              const QChar *data2, int length2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    static int compare_helper(const QChar *data1, int length1,
+                              QLatin1String s2,
+                              Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    static int localeAwareCompare_helper(const QChar *data1, int length1,
+                                         const QChar *data2, int length2);
+    static Data *fromLatin1_helper(const char *str, int size = -1);
+    static Data *fromAscii_helper(const char *str, int size = -1);
+    void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen);
+    friend class QCharRef;
+    friend class QTextCodec;
+    friend class QStringRef;
+    friend struct QAbstractConcatenable;
+    friend inline bool qStringComparisonHelper(const QString &s1, const char *s2);
+    friend inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2);
+public:
+    typedef Data * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+
+class QLatin1String
+{
+public:
+    inline explicit QLatin1String(const char *s) : chars(s) {}
+    inline QLatin1String &operator=(const QLatin1String &other)
+    { chars = other.chars; return *this; }
+
+    inline const char *latin1() const { return chars; }
+
+    inline bool operator==(const QString &s) const
+    { return s == *this; }
+    inline bool operator!=(const QString &s) const
+    { return s != *this; }
+    inline bool operator>(const QString &s) const
+    { return s < *this; }
+    inline bool operator<(const QString &s) const
+    { return s > *this; }
+    inline bool operator>=(const QString &s) const
+    { return s <= *this; }
+    inline bool operator<=(const QString &s) const
+    { return s >= *this; }
+
+    inline bool operator==(const char *s) const
+        { return QString::fromAscii(s) == *this; }
+    inline bool operator!=(const char *s) const
+        { return QString::fromAscii(s) != *this; }
+    inline bool operator<(const char *s) const
+        { return QString::fromAscii(s) > *this; }
+    inline bool operator>(const char *s) const
+        { return QString::fromAscii(s) < *this; }
+    inline bool operator<=(const char *s) const
+        { return QString::fromAscii(s) >= *this; }
+    inline bool operator>=(const char *s) const
+        { return QString::fromAscii(s) <= *this; }
+private:
+    const char *chars;
+};
+
+
+
+inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLatin1.latin1()))
+{ }
+inline int QString::length() const
+{ return d->size; }
+inline const QChar QString::at(int i) const
+{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qstring.h",688) : qt_noop()); return d->data[i]; }
+inline const QChar QString::operator[](int i) const
+{ ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qstring.h",690) : qt_noop()); return d->data[i]; }
+inline const QChar QString::operator[](uint i) const
+{ ((!(i < uint(size()))) ? qt_assert("i < uint(size())","/usr/include/qt4/QtCore/qstring.h",692) : qt_noop()); return d->data[i]; }
+inline bool QString::isEmpty() const
+{ return d->size == 0; }
+inline const QChar *QString::unicode() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline const QChar *QString::data() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline QChar *QString::data()
+{ detach(); return reinterpret_cast<QChar*>(d->data); }
+inline const QChar *QString::constData() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline void QString::detach()
+{ if (d->ref != 1 || d->data != d->array) realloc(); }
+inline bool QString::isDetached() const
+{ return d->ref == 1; }
+inline QString &QString::operator=(const QLatin1String &s)
+{
+    *this = fromLatin1(s.latin1());
+    return *this;
+}
+inline void QString::clear()
+{ if (!isNull()) *this = QString(); }
+inline QString::QString(const QString &other) : d(other.d)
+{ ((!(&other != this)) ? qt_assert("&other != this","/usr/include/qt4/QtCore/qstring.h",715) : qt_noop()); d->ref.ref(); }
+inline int QString::capacity() const
+{ return d->alloc; }
+inline QString &QString::setNum(short n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QString &QString::setNum(ushort n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QString &QString::setNum(int n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QString &QString::setNum(uint n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QString &QString::setNum(long n, int base)
+{ return setNum(qlonglong(n), base); }
+inline QString &QString::setNum(ulong n, int base)
+{ return setNum(qulonglong(n), base); }
+inline QString &QString::setNum(float n, char f, int prec)
+{ return setNum(double(n),f,prec); }
+inline QString QString::arg(int a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(uint a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(long a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(ulong a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(short a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qlonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(ushort a, int fieldWidth, int base, const QChar &fillChar) const
+{ return arg(qulonglong(a), fieldWidth, base, fillChar); }
+inline QString QString::arg(const QString &a1, const QString &a2) const
+{ const QString *args[2] = { &a1, &a2 }; return multiArg(2, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const
+{ const QString *args[3] = { &a1, &a2, &a3 }; return multiArg(3, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4) const
+{ const QString *args[4] = { &a1, &a2, &a3, &a4 }; return multiArg(4, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5) const
+{ const QString *args[5] = { &a1, &a2, &a3, &a4, &a5 }; return multiArg(5, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6) const
+{ const QString *args[6] = { &a1, &a2, &a3, &a4, &a5, &a6 }; return multiArg(6, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6,
+                            const QString &a7) const
+{ const QString *args[7] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7 }; return multiArg(7, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6,
+                            const QString &a7, const QString &a8) const
+{ const QString *args[8] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8 }; return multiArg(8, args); }
+inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3,
+                            const QString &a4, const QString &a5, const QString &a6,
+                            const QString &a7, const QString &a8, const QString &a9) const
+{ const QString *args[9] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9 }; return multiArg(9, args); }
+
+inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const
+{ return section(QString(asep), astart, aend, aflags); }
+
+
+class QCharRef {
+    QString &s;
+    int i;
+    inline QCharRef(QString &str, int idx)
+        : s(str),i(idx) {}
+    friend class QString;
+public:
+
+
+
+
+    inline operator QChar() const
+        { return i < s.d->size ? s.d->data[i] : 0; }
+    inline QCharRef &operator=(const QChar &c)
+        { if (i >= s.d->size) s.expand(i); else s.detach();
+          s.d->data[i] = c.unicode(); return *this; }
+
+
+
+    inline QCharRef &operator=(char c)
+    { return operator=(QChar::fromAscii(c)); }
+    inline QCharRef &operator=(uchar c)
+    { return operator=(QChar::fromAscii(c)); }
+
+    inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); }
+    inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); }
+    inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); }
+    inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); }
+    inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); }
+
+
+    inline bool isNull() const { return QChar(*this).isNull(); }
+    inline bool isPrint() const { return QChar(*this).isPrint(); }
+    inline bool isPunct() const { return QChar(*this).isPunct(); }
+    inline bool isSpace() const { return QChar(*this).isSpace(); }
+    inline bool isMark() const { return QChar(*this).isMark(); }
+    inline bool isLetter() const { return QChar(*this).isLetter(); }
+    inline bool isNumber() const { return QChar(*this).isNumber(); }
+    inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); }
+    inline bool isDigit() const { return QChar(*this).isDigit(); }
+    inline bool isLower() const { return QChar(*this).isLower(); }
+    inline bool isUpper() const { return QChar(*this).isUpper(); }
+    inline bool isTitleCase() const { return QChar(*this).isTitleCase(); }
+
+    inline int digitValue() const { return QChar(*this).digitValue(); }
+    QChar toLower() const { return QChar(*this).toLower(); }
+    QChar toUpper() const { return QChar(*this).toUpper(); }
+    QChar toTitleCase () const { return QChar(*this).toTitleCase(); }
+
+    QChar::Category category() const { return QChar(*this).category(); }
+    QChar::Direction direction() const { return QChar(*this).direction(); }
+    QChar::Joining joining() const { return QChar(*this).joining(); }
+    bool hasMirrored() const { return QChar(*this).hasMirrored(); }
+    QChar mirroredChar() const { return QChar(*this).mirroredChar(); }
+    QString decomposition() const { return QChar(*this).decomposition(); }
+    QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); }
+    uchar combiningClass() const { return QChar(*this).combiningClass(); }
+
+    QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); }
+
+    inline uchar cell() const { return QChar(*this).cell(); }
+    inline uchar row() const { return QChar(*this).row(); }
+    inline void setCell(uchar cell);
+    inline void setRow(uchar row);
+
+
+
+
+
+
+    char toAscii() const { return QChar(*this).toAscii(); }
+    char toLatin1() const { return QChar(*this).toLatin1(); }
+    ushort unicode() const { return QChar(*this).unicode(); }
+
+    ushort& unicode() { return s.data()[i].unicode(); }
+# 862 "/usr/include/qt4/QtCore/qstring.h"
+};
+
+inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); }
+inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); }
+
+
+inline QString::QString() : d(&shared_null) { d->ref.ref(); }
+inline QString::~QString() { if (!d->ref.deref()) free(d); }
+inline void QString::reserve(int asize) { if (d->ref != 1 || asize > d->alloc) realloc(asize); d->capacity = 1;}
+inline QString &QString::setUtf16(const ushort *autf16, int asize)
+{ return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); }
+inline QCharRef QString::operator[](int i)
+{ ((!(i >= 0)) ? qt_assert("i >= 0","/usr/include/qt4/QtCore/qstring.h",874) : qt_noop()); return QCharRef(*this, i); }
+inline QCharRef QString::operator[](uint i)
+{ return QCharRef(*this, i); }
+inline QString::iterator QString::begin()
+{ detach(); return reinterpret_cast<QChar*>(d->data); }
+inline QString::const_iterator QString::begin() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline QString::const_iterator QString::constBegin() const
+{ return reinterpret_cast<const QChar*>(d->data); }
+inline QString::iterator QString::end()
+{ detach(); return reinterpret_cast<QChar*>(d->data + d->size); }
+inline QString::const_iterator QString::end() const
+{ return reinterpret_cast<const QChar*>(d->data + d->size); }
+inline QString::const_iterator QString::constEnd() const
+{ return reinterpret_cast<const QChar*>(d->data + d->size); }
+inline QBool QString::contains(const QString &s, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(s, 0, cs) != -1); }
+inline QBool QString::contains(QChar c, Qt::CaseSensitivity cs) const
+{ return QBool(indexOf(c, 0, cs) != -1); }
+
+
+inline bool operator==(QString::Null, QString::Null) { return true; }
+inline bool operator==(QString::Null, const QString &s) { return s.isNull(); }
+inline bool operator==(const QString &s, QString::Null) { return s.isNull(); }
+inline bool operator!=(QString::Null, QString::Null) { return false; }
+inline bool operator!=(QString::Null, const QString &s) { return !s.isNull(); }
+inline bool operator!=(const QString &s, QString::Null) { return !s.isNull(); }
+
+
+inline bool qStringComparisonHelper(const QString &s1, const char *s2)
+{
+
+    if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2));
+
+    return (s1 == QLatin1String(s2));
+}
+inline bool QString::operator==(const char *s) const
+{ return qStringComparisonHelper(*this, s); }
+inline bool QString::operator!=(const char *s) const
+{ return !qStringComparisonHelper(*this, s); }
+inline bool QString::operator<(const char *s) const
+{ return *this < QString::fromAscii(s); }
+inline bool QString::operator>(const char *s) const
+{ return *this > QString::fromAscii(s); }
+inline bool QString::operator<=(const char *s) const
+{ return *this <= QString::fromAscii(s); }
+inline bool QString::operator>=(const char *s) const
+{ return *this >= QString::fromAscii(s); }
+
+inline bool operator==(const char *s1, const QString &s2)
+{ return qStringComparisonHelper(s2, s1); }
+inline bool operator!=(const char *s1, const QString &s2)
+{ return !qStringComparisonHelper(s2, s1); }
+inline bool operator<(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) < s2); }
+inline bool operator>(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) > s2); }
+inline bool operator<=(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) <= s2); }
+inline bool operator>=(const char *s1, const QString &s2)
+{ return (QString::fromAscii(s1) >= s2); }
+
+inline bool operator==(const char *s1, const QLatin1String &s2)
+{ return QString::fromAscii(s1) == s2; }
+inline bool operator!=(const char *s1, const QLatin1String &s2)
+{ return QString::fromAscii(s1) != s2; }
+inline bool operator<(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) < s2); }
+inline bool operator>(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) > s2); }
+inline bool operator<=(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) <= s2); }
+inline bool operator>=(const char *s1, const QLatin1String &s2)
+{ return (QString::fromAscii(s1) >= s2); }
+
+inline bool operator==(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) == 0); }
+inline bool operator!=(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) != 0); }
+inline bool operator<(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) < 0); }
+inline bool operator<=(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) <= 0); }
+inline bool operator>(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) > 0); }
+inline bool operator>=(const QLatin1String &s1, const QLatin1String &s2)
+{ return (qstrcmp(s1.latin1(), s2.latin1()) >= 0); }
+
+
+inline bool QString::operator==(const QByteArray &s) const
+{ return qStringComparisonHelper(*this, s.constData()); }
+inline bool QString::operator!=(const QByteArray &s) const
+{ return !qStringComparisonHelper(*this, s.constData()); }
+
+inline bool QByteArray::operator==(const QString &s) const
+{ return qStringComparisonHelper(s, constData()); }
+inline bool QByteArray::operator!=(const QString &s) const
+{ return !qStringComparisonHelper(s, constData()); }
+inline bool QByteArray::operator<(const QString &s) const
+{ return QString::fromAscii(constData(), size()) < s; }
+inline bool QByteArray::operator>(const QString &s) const
+{ return QString::fromAscii(constData(), size()) > s; }
+inline bool QByteArray::operator<=(const QString &s) const
+{ return QString::fromAscii(constData(), size()) <= s; }
+inline bool QByteArray::operator>=(const QString &s) const
+{ return QString::fromAscii(constData(), size()) >= s; }
+
+
+
+inline QByteArray &QByteArray::append(const QString &s)
+{ return append(s.toAscii()); }
+inline QByteArray &QByteArray::insert(int i, const QString &s)
+{ return insert(i, s.toAscii()); }
+inline QByteArray &QByteArray::replace(char c, const QString &after)
+{ return replace(c, after.toAscii()); }
+inline QByteArray &QByteArray::replace(const QString &before, const char *after)
+{ return replace(before.toAscii(), after); }
+inline QByteArray &QByteArray::replace(const QString &before, const QByteArray &after)
+{ return replace(before.toAscii(), after); }
+inline QByteArray &QByteArray::operator+=(const QString &s)
+{ return operator+=(s.toAscii()); }
+inline int QByteArray::indexOf(const QString &s, int from) const
+{ return indexOf(s.toAscii(), from); }
+inline int QByteArray::lastIndexOf(const QString &s, int from) const
+{ return lastIndexOf(s.toAscii(), from); }
+# 1009 "/usr/include/qt4/QtCore/qstring.h"
+inline const QString operator+(const QString &s1, const QString &s2)
+{ QString t(s1); t += s2; return t; }
+inline const QString operator+(const QString &s1, QChar s2)
+{ QString t(s1); t += s2; return t; }
+inline const QString operator+(QChar s1, const QString &s2)
+{ QString t(s1); t += s2; return t; }
+
+inline const QString operator+(const QString &s1, const char *s2)
+{ QString t(s1); t += QString::fromAscii(s2); return t; }
+inline const QString operator+(const char *s1, const QString &s2)
+{ QString t = QString::fromAscii(s1); t += s2; return t; }
+inline const QString operator+(char c, const QString &s)
+{ QString t = s; t.prepend(QChar::fromAscii(c)); return t; }
+inline const QString operator+(const QString &s, char c)
+{ QString t = s; t += QChar::fromAscii(c); return t; }
+inline const QString operator+(const QByteArray &ba, const QString &s)
+{ QString t = QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); t += s; return t; }
+inline const QString operator+(const QString &s, const QByteArray &ba)
+{ QString t(s); t += QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); return t; }
+
+
+
+
+
+inline std::string QString::toStdString() const
+{ const QByteArray asc = toAscii(); return std::string(asc.constData(), asc.length()); }
+
+inline QString QString::fromStdString(const std::string &s)
+{ return fromAscii(s.data(), int(s.size())); }
+
+
+inline QStdWString QString::toStdWString() const
+{
+    QStdWString str;
+    str.resize(length());
+
+
+
+
+
+
+
+    str.resize(toWCharArray(&(*str.begin())));
+    return str;
+}
+inline QString QString::fromStdWString(const QStdWString &s)
+{ return fromWCharArray(s.data(), int(s.size())); }
+# 1069 "/usr/include/qt4/QtCore/qstring.h"
+ QDataStream &operator<<(QDataStream &, const QString &);
+ QDataStream &operator>>(QDataStream &, QString &);
+# 1083 "/usr/include/qt4/QtCore/qstring.h"
+template <> class QTypeInfo<QString > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QString)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QString"; } };
+template <> inline bool qIsDetached<QString>(QString &t) { return t.isDetached(); } template <> inline void qSwap<QString>(QString &value1, QString &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) { return QFlags<QString::SectionFlags::enum_type>(f1) | f2; } inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QFlags<QString::SectionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+# 1094 "/usr/include/qt4/QtCore/qstring.h"
+class QStringRef {
+    const QString *m_string;
+    int m_position;
+    int m_size;
+public:
+    inline QStringRef():m_string(0), m_position(0), m_size(0){}
+    inline QStringRef(const QString *string, int position, int size);
+    inline QStringRef(const QString *string);
+    inline QStringRef(const QStringRef &other)
+        :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size)
+        {}
+
+    inline ~QStringRef(){}
+    inline const QString *string() const { return m_string; }
+    inline int position() const { return m_position; }
+    inline int size() const { return m_size; }
+    inline int count() const { return m_size; }
+    inline int length() const { return m_size; }
+
+    inline QStringRef &operator=(const QStringRef &other) {
+        m_string = other.m_string; m_position = other.m_position;
+        m_size = other.m_size; return *this;
+    }
+
+    inline QStringRef &operator=(const QString *string);
+
+    inline const QChar *unicode() const {
+        if (!m_string)
+            return reinterpret_cast<const QChar *>(QString::shared_null.data);
+        return m_string->unicode() + m_position;
+    }
+    inline const QChar *data() const { return unicode(); }
+    inline const QChar *constData() const { return unicode(); }
+
+    inline void clear() { m_string = 0; m_position = m_size = 0; }
+    QString toString() const;
+    inline bool isEmpty() const { return m_size == 0; }
+    inline bool isNull() const { return m_string == 0 || m_string->isNull(); }
+
+    QStringRef appendTo(QString *string) const;
+
+    inline const QChar at(int i) const
+        { ((!(i >= 0 && i < size())) ? qt_assert("i >= 0 && i < size()","/usr/include/qt4/QtCore/qstring.h",1136) : qt_noop()); return m_string->at(i + m_position); }
+
+    int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    static int compare(const QStringRef &s1, const QString &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive);
+    static int compare(const QStringRef &s1, const QStringRef &s2,
+                       Qt::CaseSensitivity = Qt::CaseSensitive);
+    static int compare(const QStringRef &s1, QLatin1String s2,
+                       Qt::CaseSensitivity cs = Qt::CaseSensitive);
+
+    int localeAwareCompare(const QString &s) const;
+    int localeAwareCompare(const QStringRef &s) const;
+    static int localeAwareCompare(const QStringRef &s1, const QString &s2);
+    static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2);
+};
+
+inline QStringRef &QStringRef::operator=(const QString *aString)
+{ m_string = aString; m_position = 0; m_size = aString?aString->size():0; return *this; }
+
+inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize)
+        :m_string(aString), m_position(aPosition), m_size(aSize){}
+
+inline QStringRef::QStringRef(const QString *aString)
+    :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){}
+
+ bool operator==(const QStringRef &s1,const QStringRef &s2);
+inline bool operator!=(const QStringRef &s1,const QStringRef &s2)
+{ return !(s1 == s2); }
+ bool operator==(const QString &s1,const QStringRef &s2);
+inline bool operator!=(const QString &s1,const QStringRef &s2)
+{ return !(s1 == s2); }
+inline bool operator==(const QStringRef &s1,const QString &s2)
+{ return s2 == s1; }
+inline bool operator!=(const QStringRef &s1,const QString &s2)
+{ return s2 != s1; }
+ bool operator==(const QLatin1String &s1, const QStringRef &s2);
+inline bool operator!=(const QLatin1String &s1,const QStringRef &s2)
+{ return !(s1 == s2); }
+inline bool operator==(const QStringRef &s1,const QLatin1String &s2)
+{ return s2 == s1; }
+inline bool operator!=(const QStringRef &s1,const QLatin1String &s2)
+{ return s2 != s1; }
+
+ bool operator<(const QStringRef &s1,const QStringRef &s2);
+inline bool operator>(const QStringRef &s1, const QStringRef &s2)
+{ return s2 < s1; }
+inline bool operator<=(const QStringRef &s1, const QStringRef &s2)
+{ return !(s1 > s2); }
+inline bool operator>=(const QStringRef &s1, const QStringRef &s2)
+{ return !(s1 < s2); }
+
+inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2)
+{
+
+    if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2));
+
+    return (s1 == QLatin1String(s2));
+}
+
+inline bool operator==(const char *s1, const QStringRef &s2)
+{ return qStringComparisonHelper(s2, s1); }
+inline bool operator==(const QStringRef &s1, const char *s2)
+{ return qStringComparisonHelper(s1, s2); }
+inline bool operator!=(const char *s1, const QStringRef &s2)
+{ return !qStringComparisonHelper(s2, s1); }
+inline bool operator!=(const QStringRef &s1, const char *s2)
+{ return !qStringComparisonHelper(s1, s2); }
+
+inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); }
+inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const
+{ return QString::compare_helper(constData(), length(), s, cs); }
+inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); }
+inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs)
+{ return QString::compare_helper(s1.constData(), s1.length(), s2, cs); }
+
+inline int QString::localeAwareCompare(const QStringRef &s) const
+{ return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
+inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2)
+{ return localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
+inline int QStringRef::localeAwareCompare(const QString &s) const
+{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
+inline int QStringRef::localeAwareCompare(const QStringRef &s) const
+{ return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); }
+inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s2)
+{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
+inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2)
+{ return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); }
+
+
+
+
+
+# 26 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2
+# 1 "/usr/include/qt4/QtGui/qpixmap.h" 1
+# 45 "/usr/include/qt4/QtGui/qpixmap.h"
+# 1 "/usr/include/qt4/QtGui/qpaintdevice.h" 1
+# 45 "/usr/include/qt4/QtGui/qpaintdevice.h"
+# 1 "/usr/include/qt4/QtGui/qwindowdefs.h" 1
+# 45 "/usr/include/qt4/QtGui/qwindowdefs.h"
+# 1 "/usr/include/qt4/QtCore/qobjectdefs.h" 1
+# 47 "/usr/include/qt4/QtCore/qobjectdefs.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QByteArray;
+
+class QString;
+# 141 "/usr/include/qt4/QtCore/qobjectdefs.h"
+template <typename T>
+inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; }
+
+template <typename T1, typename T2>
+inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {}
+# 210 "/usr/include/qt4/QtCore/qobjectdefs.h"
+ const char *qFlagLocation(const char *method);
+# 238 "/usr/include/qt4/QtCore/qobjectdefs.h"
+class QObject;
+class QMetaMethod;
+class QMetaEnum;
+class QMetaProperty;
+class QMetaClassInfo;
+
+
+class QGenericArgument
+{
+public:
+    inline QGenericArgument(const char *aName = 0, const void *aData = 0)
+        : _data(aData), _name(aName) {}
+    inline void *data() const { return const_cast<void *>(_data); }
+    inline const char *name() const { return _name; }
+
+private:
+    const void *_data;
+    const char *_name;
+};
+
+class QGenericReturnArgument: public QGenericArgument
+{
+public:
+    inline QGenericReturnArgument(const char *aName = 0, void *aData = 0)
+        : QGenericArgument(aName, aData)
+        {}
+};
+
+template <class T>
+class QArgument: public QGenericArgument
+{
+public:
+    inline QArgument(const char *aName, const T &aData)
+        : QGenericArgument(aName, static_cast<const void *>(&aData))
+        {}
+};
+
+
+template <typename T>
+class QReturnArgument: public QGenericReturnArgument
+{
+public:
+    inline QReturnArgument(const char *aName, T &aData)
+        : QGenericReturnArgument(aName, static_cast<void *>(&aData))
+        {}
+};
+
+struct QMetaObject
+{
+    const char *className() const;
+    const QMetaObject *superClass() const;
+
+    QObject *cast(QObject *obj) const;
+
+
+
+    QString tr(const char *s, const char *c) const;
+    QString trUtf8(const char *s, const char *c) const;
+    QString tr(const char *s, const char *c, int n) const;
+    QString trUtf8(const char *s, const char *c, int n) const;
+
+
+    int methodOffset() const;
+    int enumeratorOffset() const;
+    int propertyOffset() const;
+    int classInfoOffset() const;
+
+    int constructorCount() const;
+    int methodCount() const;
+    int enumeratorCount() const;
+    int propertyCount() const;
+    int classInfoCount() const;
+
+    int indexOfConstructor(const char *constructor) const;
+    int indexOfMethod(const char *method) const;
+    int indexOfSignal(const char *signal) const;
+    int indexOfSlot(const char *slot) const;
+    int indexOfEnumerator(const char *name) const;
+    int indexOfProperty(const char *name) const;
+    int indexOfClassInfo(const char *name) const;
+
+    QMetaMethod constructor(int index) const;
+    QMetaMethod method(int index) const;
+    QMetaEnum enumerator(int index) const;
+    QMetaProperty property(int index) const;
+    QMetaClassInfo classInfo(int index) const;
+    QMetaProperty userProperty() const;
+
+    static bool checkConnectArgs(const char *signal, const char *method);
+    static QByteArray normalizedSignature(const char *method);
+    static QByteArray normalizedType(const char *type);
+
+
+    static bool connect(const QObject *sender, int signal_index,
+                        const QObject *receiver, int method_index,
+                        int type = 0, int *types = 0);
+
+    static bool disconnect(const QObject *sender, int signal_index,
+                           const QObject *receiver, int method_index);
+    static bool disconnectOne(const QObject *sender, int signal_index,
+                              const QObject *receiver, int method_index);
+
+    static void connectSlotsByName(QObject *o);
+
+
+    static void activate(QObject *sender, int signal_index, void **argv);
+    static void activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv);
+    static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv);
+    static void activate(QObject *sender, const QMetaObject *, int from_local_signal_index, int to_local_signal_index, void **argv);
+
+
+    static void addGuard(QObject **ptr);
+    static void removeGuard(QObject **ptr);
+    static void changeGuard(QObject **ptr, QObject *o);
+
+    static bool invokeMethod(QObject *obj, const char *member,
+                             Qt::ConnectionType,
+                             QGenericReturnArgument ret,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument());
+
+    static inline bool invokeMethod(QObject *obj, const char *member,
+                             QGenericReturnArgument ret,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument())
+    {
+        return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3,
+                val4, val5, val6, val7, val8, val9);
+    }
+
+    static inline bool invokeMethod(QObject *obj, const char *member,
+                             Qt::ConnectionType type,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument())
+    {
+        return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2,
+                                 val3, val4, val5, val6, val7, val8, val9);
+    }
+
+    static inline bool invokeMethod(QObject *obj, const char *member,
+                             QGenericArgument val0 = QGenericArgument(0),
+                             QGenericArgument val1 = QGenericArgument(),
+                             QGenericArgument val2 = QGenericArgument(),
+                             QGenericArgument val3 = QGenericArgument(),
+                             QGenericArgument val4 = QGenericArgument(),
+                             QGenericArgument val5 = QGenericArgument(),
+                             QGenericArgument val6 = QGenericArgument(),
+                             QGenericArgument val7 = QGenericArgument(),
+                             QGenericArgument val8 = QGenericArgument(),
+                             QGenericArgument val9 = QGenericArgument())
+    {
+        return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0,
+                val1, val2, val3, val4, val5, val6, val7, val8, val9);
+    }
+
+    QObject *newInstance(QGenericArgument val0 = QGenericArgument(0),
+                         QGenericArgument val1 = QGenericArgument(),
+                         QGenericArgument val2 = QGenericArgument(),
+                         QGenericArgument val3 = QGenericArgument(),
+                         QGenericArgument val4 = QGenericArgument(),
+                         QGenericArgument val5 = QGenericArgument(),
+                         QGenericArgument val6 = QGenericArgument(),
+                         QGenericArgument val7 = QGenericArgument(),
+                         QGenericArgument val8 = QGenericArgument(),
+                         QGenericArgument val9 = QGenericArgument()) const;
+
+    enum Call {
+        InvokeMetaMethod,
+        ReadProperty,
+        WriteProperty,
+        ResetProperty,
+        QueryPropertyDesignable,
+        QueryPropertyScriptable,
+        QueryPropertyStored,
+        QueryPropertyEditable,
+        QueryPropertyUser,
+        CreateInstance
+    };
+
+    int static_metacall(Call, int, void **) const;
+    static int metacall(QObject *, Call, int, void **);
+
+
+
+
+
+    struct {
+        const QMetaObject *superdata;
+        const char *stringdata;
+        const uint *data;
+        const void *extradata;
+    } d;
+
+};
+
+typedef const QMetaObject& (*QMetaObjectAccessor)();
+
+struct QMetaObjectExtraData
+{
+
+
+
+    const QMetaObject **objects;
+
+    int (*static_metacall)(QMetaObject::Call, int, void **);
+};
+
+inline const char *QMetaObject::className() const
+{ return d.stringdata; }
+
+inline const QMetaObject *QMetaObject::superClass() const
+{ return d.superdata; }
+
+
+
+
+
+
+
+
+
+# 46 "/usr/include/qt4/QtGui/qwindowdefs.h" 2
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+
+
+class QPaintDevice;
+class QWidget;
+class QDialog;
+class QColor;
+class QPalette;
+
+
+
+class QCursor;
+class QPoint;
+class QSize;
+class QRect;
+class QPolygon;
+class QPainter;
+class QRegion;
+class QFont;
+class QFontMetrics;
+class QFontInfo;
+class QPen;
+class QBrush;
+class QMatrix;
+class QPixmap;
+class QBitmap;
+class QMovie;
+class QImage;
+class QPicture;
+class QPrinter;
+class QTimer;
+class QTime;
+class QClipboard;
+class QString;
+class QByteArray;
+class QApplication;
+
+template<typename T> class QList;
+typedef QList<QWidget *> QWidgetList;
+
+
+
+# 115 "/usr/include/qt4/QtGui/qwindowdefs.h"
+typedef struct _XDisplay Display;
+typedef union _XEvent XEvent;
+typedef struct _XGC *GC;
+typedef struct _XRegion *Region;
+typedef unsigned long WId;
+# 139 "/usr/include/qt4/QtGui/qwindowdefs.h"
+
+
+
+template<class K, class V> class QHash;
+typedef QHash<WId, QWidget *> QWidgetMapper;
+
+template<class V> class QSet;
+typedef QSet<QWidget *> QWidgetSet;
+
+
+
+# 46 "/usr/include/qt4/QtGui/qpaintdevice.h" 2
+# 1 "/usr/include/qt4/QtCore/qrect.h" 1
+# 45 "/usr/include/qt4/QtCore/qrect.h"
+# 1 "/usr/include/qt4/QtCore/qsize.h" 1
+# 47 "/usr/include/qt4/QtCore/qsize.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QSize
+{
+public:
+    QSize();
+    QSize(int w, int h);
+
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+
+    int width() const;
+    int height() const;
+    void setWidth(int w);
+    void setHeight(int h);
+    void transpose();
+
+    void scale(int w, int h, Qt::AspectRatioMode mode);
+    void scale(const QSize &s, Qt::AspectRatioMode mode);
+
+    QSize expandedTo(const QSize &) const;
+    QSize boundedTo(const QSize &) const;
+
+    int &rwidth();
+    int &rheight();
+
+    QSize &operator+=(const QSize &);
+    QSize &operator-=(const QSize &);
+    QSize &operator*=(qreal c);
+    QSize &operator/=(qreal c);
+
+    friend inline bool operator==(const QSize &, const QSize &);
+    friend inline bool operator!=(const QSize &, const QSize &);
+    friend inline const QSize operator+(const QSize &, const QSize &);
+    friend inline const QSize operator-(const QSize &, const QSize &);
+    friend inline const QSize operator*(const QSize &, qreal);
+    friend inline const QSize operator*(qreal, const QSize &);
+    friend inline const QSize operator/(const QSize &, qreal);
+
+private:
+    int wd;
+    int ht;
+};
+template <> class QTypeInfo<QSize > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSize)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSize"; } };
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QSize &);
+ QDataStream &operator>>(QDataStream &, QSize &);
+
+
+
+
+
+
+
+inline QSize::QSize()
+{ wd = ht = -1; }
+
+inline QSize::QSize(int w, int h)
+{ wd = w; ht = h; }
+
+inline bool QSize::isNull() const
+{ return wd==0 && ht==0; }
+
+inline bool QSize::isEmpty() const
+{ return wd<1 || ht<1; }
+
+inline bool QSize::isValid() const
+{ return wd>=0 && ht>=0; }
+
+inline int QSize::width() const
+{ return wd; }
+
+inline int QSize::height() const
+{ return ht; }
+
+inline void QSize::setWidth(int w)
+{ wd = w; }
+
+inline void QSize::setHeight(int h)
+{ ht = h; }
+
+inline void QSize::scale(int w, int h, Qt::AspectRatioMode mode)
+{ scale(QSize(w, h), mode); }
+
+inline int &QSize::rwidth()
+{ return wd; }
+
+inline int &QSize::rheight()
+{ return ht; }
+
+inline QSize &QSize::operator+=(const QSize &s)
+{ wd+=s.wd; ht+=s.ht; return *this; }
+
+inline QSize &QSize::operator-=(const QSize &s)
+{ wd-=s.wd; ht-=s.ht; return *this; }
+
+inline QSize &QSize::operator*=(qreal c)
+{ wd = qRound(wd*c); ht = qRound(ht*c); return *this; }
+
+inline bool operator==(const QSize &s1, const QSize &s2)
+{ return s1.wd == s2.wd && s1.ht == s2.ht; }
+
+inline bool operator!=(const QSize &s1, const QSize &s2)
+{ return s1.wd != s2.wd || s1.ht != s2.ht; }
+
+inline const QSize operator+(const QSize & s1, const QSize & s2)
+{ return QSize(s1.wd+s2.wd, s1.ht+s2.ht); }
+
+inline const QSize operator-(const QSize &s1, const QSize &s2)
+{ return QSize(s1.wd-s2.wd, s1.ht-s2.ht); }
+
+inline const QSize operator*(const QSize &s, qreal c)
+{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }
+
+inline const QSize operator*(qreal c, const QSize &s)
+{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }
+
+inline QSize &QSize::operator/=(qreal c)
+{
+    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",176) : qt_noop());
+    wd = qRound(wd/c); ht = qRound(ht/c);
+    return *this;
+}
+
+inline const QSize operator/(const QSize &s, qreal c)
+{
+    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",183) : qt_noop());
+    return QSize(qRound(s.wd/c), qRound(s.ht/c));
+}
+
+inline QSize QSize::expandedTo(const QSize & otherSize) const
+{
+    return QSize(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht));
+}
+
+inline QSize QSize::boundedTo(const QSize & otherSize) const
+{
+    return QSize(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
+}
+
+
+ QDebug operator<<(QDebug, const QSize &);
+
+
+
+class QSizeF
+{
+public:
+    QSizeF();
+    QSizeF(const QSize &sz);
+    QSizeF(qreal w, qreal h);
+
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+
+    qreal width() const;
+    qreal height() const;
+    void setWidth(qreal w);
+    void setHeight(qreal h);
+    void transpose();
+
+    void scale(qreal w, qreal h, Qt::AspectRatioMode mode);
+    void scale(const QSizeF &s, Qt::AspectRatioMode mode);
+
+    QSizeF expandedTo(const QSizeF &) const;
+    QSizeF boundedTo(const QSizeF &) const;
+
+    qreal &rwidth();
+    qreal &rheight();
+
+    QSizeF &operator+=(const QSizeF &);
+    QSizeF &operator-=(const QSizeF &);
+    QSizeF &operator*=(qreal c);
+    QSizeF &operator/=(qreal c);
+
+    friend inline bool operator==(const QSizeF &, const QSizeF &);
+    friend inline bool operator!=(const QSizeF &, const QSizeF &);
+    friend inline const QSizeF operator+(const QSizeF &, const QSizeF &);
+    friend inline const QSizeF operator-(const QSizeF &, const QSizeF &);
+    friend inline const QSizeF operator*(const QSizeF &, qreal);
+    friend inline const QSizeF operator*(qreal, const QSizeF &);
+    friend inline const QSizeF operator/(const QSizeF &, qreal);
+
+    inline QSize toSize() const;
+
+private:
+    qreal wd;
+    qreal ht;
+};
+template <> class QTypeInfo<QSizeF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSizeF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSizeF"; } };
+
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QSizeF &);
+ QDataStream &operator>>(QDataStream &, QSizeF &);
+
+
+
+
+
+
+
+inline QSizeF::QSizeF()
+{ wd = ht = -1.; }
+
+inline QSizeF::QSizeF(const QSize &sz)
+    : wd(sz.width()), ht(sz.height())
+{
+}
+
+inline QSizeF::QSizeF(qreal w, qreal h)
+{ wd = w; ht = h; }
+
+inline bool QSizeF::isNull() const
+{ return qIsNull(wd) && qIsNull(ht); }
+
+inline bool QSizeF::isEmpty() const
+{ return wd <= 0. || ht <= 0.; }
+
+inline bool QSizeF::isValid() const
+{ return wd >= 0. && ht >= 0.; }
+
+inline qreal QSizeF::width() const
+{ return wd; }
+
+inline qreal QSizeF::height() const
+{ return ht; }
+
+inline void QSizeF::setWidth(qreal w)
+{ wd = w; }
+
+inline void QSizeF::setHeight(qreal h)
+{ ht = h; }
+
+inline void QSizeF::scale(qreal w, qreal h, Qt::AspectRatioMode mode)
+{ scale(QSizeF(w, h), mode); }
+
+inline qreal &QSizeF::rwidth()
+{ return wd; }
+
+inline qreal &QSizeF::rheight()
+{ return ht; }
+
+inline QSizeF &QSizeF::operator+=(const QSizeF &s)
+{ wd += s.wd; ht += s.ht; return *this; }
+
+inline QSizeF &QSizeF::operator-=(const QSizeF &s)
+{ wd -= s.wd; ht -= s.ht; return *this; }
+
+inline QSizeF &QSizeF::operator*=(qreal c)
+{ wd *= c; ht *= c; return *this; }
+
+inline bool operator==(const QSizeF &s1, const QSizeF &s2)
+{ return qFuzzyCompare(s1.wd, s2.wd) && qFuzzyCompare(s1.ht, s2.ht); }
+
+inline bool operator!=(const QSizeF &s1, const QSizeF &s2)
+{ return !qFuzzyCompare(s1.wd, s2.wd) || !qFuzzyCompare(s1.ht, s2.ht); }
+
+inline const QSizeF operator+(const QSizeF & s1, const QSizeF & s2)
+{ return QSizeF(s1.wd+s2.wd, s1.ht+s2.ht); }
+
+inline const QSizeF operator-(const QSizeF &s1, const QSizeF &s2)
+{ return QSizeF(s1.wd-s2.wd, s1.ht-s2.ht); }
+
+inline const QSizeF operator*(const QSizeF &s, qreal c)
+{ return QSizeF(s.wd*c, s.ht*c); }
+
+inline const QSizeF operator*(qreal c, const QSizeF &s)
+{ return QSizeF(s.wd*c, s.ht*c); }
+
+inline QSizeF &QSizeF::operator/=(qreal c)
+{
+    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",334) : qt_noop());
+    wd = wd/c; ht = ht/c;
+    return *this;
+}
+
+inline const QSizeF operator/(const QSizeF &s, qreal c)
+{
+    ((!(!qFuzzyIsNull(c))) ? qt_assert("!qFuzzyIsNull(c)","/usr/include/qt4/QtCore/qsize.h",341) : qt_noop());
+    return QSizeF(s.wd/c, s.ht/c);
+}
+
+inline QSizeF QSizeF::expandedTo(const QSizeF & otherSize) const
+{
+    return QSizeF(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht));
+}
+
+inline QSizeF QSizeF::boundedTo(const QSizeF & otherSize) const
+{
+    return QSizeF(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht));
+}
+
+inline QSize QSizeF::toSize() const
+{
+    return QSize(qRound(wd), qRound(ht));
+}
+
+
+ QDebug operator<<(QDebug, const QSizeF &);
+
+
+
+
+
+# 46 "/usr/include/qt4/QtCore/qrect.h" 2
+# 1 "/usr/include/qt4/QtCore/qpoint.h" 1
+# 47 "/usr/include/qt4/QtCore/qpoint.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QPoint
+{
+public:
+    QPoint();
+    QPoint(int xpos, int ypos);
+
+    bool isNull() const;
+
+    int x() const;
+    int y() const;
+    void setX(int x);
+    void setY(int y);
+
+    int manhattanLength() const;
+
+    int &rx();
+    int &ry();
+
+    QPoint &operator+=(const QPoint &p);
+    QPoint &operator-=(const QPoint &p);
+    QPoint &operator*=(qreal c);
+    QPoint &operator/=(qreal c);
+
+    friend inline bool operator==(const QPoint &, const QPoint &);
+    friend inline bool operator!=(const QPoint &, const QPoint &);
+    friend inline const QPoint operator+(const QPoint &, const QPoint &);
+    friend inline const QPoint operator-(const QPoint &, const QPoint &);
+    friend inline const QPoint operator*(const QPoint &, qreal);
+    friend inline const QPoint operator*(qreal, const QPoint &);
+    friend inline const QPoint operator-(const QPoint &);
+    friend inline const QPoint operator/(const QPoint &, qreal);
+
+private:
+    friend class QTransform;
+
+
+
+
+
+    int xp;
+    int yp;
+
+};
+
+template <> class QTypeInfo<QPoint > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPoint"; } };
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QPoint &);
+ QDataStream &operator>>(QDataStream &, QPoint &);
+
+
+
+
+
+
+inline QPoint::QPoint()
+{ xp=0; yp=0; }
+
+inline QPoint::QPoint(int xpos, int ypos)
+{ xp = xpos; yp = ypos; }
+
+inline bool QPoint::isNull() const
+{ return xp == 0 && yp == 0; }
+
+inline int QPoint::x() const
+{ return xp; }
+
+inline int QPoint::y() const
+{ return yp; }
+
+inline void QPoint::setX(int xpos)
+{ xp = xpos; }
+
+inline void QPoint::setY(int ypos)
+{ yp = ypos; }
+
+inline int &QPoint::rx()
+{ return xp; }
+
+inline int &QPoint::ry()
+{ return yp; }
+
+inline QPoint &QPoint::operator+=(const QPoint &p)
+{ xp+=p.xp; yp+=p.yp; return *this; }
+
+inline QPoint &QPoint::operator-=(const QPoint &p)
+{ xp-=p.xp; yp-=p.yp; return *this; }
+
+inline QPoint &QPoint::operator*=(qreal c)
+{ xp = qRound(xp*c); yp = qRound(yp*c); return *this; }
+
+inline bool operator==(const QPoint &p1, const QPoint &p2)
+{ return p1.xp == p2.xp && p1.yp == p2.yp; }
+
+inline bool operator!=(const QPoint &p1, const QPoint &p2)
+{ return p1.xp != p2.xp || p1.yp != p2.yp; }
+
+inline const QPoint operator+(const QPoint &p1, const QPoint &p2)
+{ return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); }
+
+inline const QPoint operator-(const QPoint &p1, const QPoint &p2)
+{ return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); }
+
+inline const QPoint operator*(const QPoint &p, qreal c)
+{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }
+
+inline const QPoint operator*(qreal c, const QPoint &p)
+{ return QPoint(qRound(p.xp*c), qRound(p.yp*c)); }
+
+inline const QPoint operator-(const QPoint &p)
+{ return QPoint(-p.xp, -p.yp); }
+
+inline QPoint &QPoint::operator/=(qreal c)
+{
+    xp = qRound(xp/c);
+    yp = qRound(yp/c);
+    return *this;
+}
+
+inline const QPoint operator/(const QPoint &p, qreal c)
+{
+    return QPoint(qRound(p.xp/c), qRound(p.yp/c));
+}
+
+
+ QDebug operator<<(QDebug, const QPoint &);
+
+
+
+
+
+
+class QPointF
+{
+public:
+    QPointF();
+    QPointF(const QPoint &p);
+    QPointF(qreal xpos, qreal ypos);
+
+    qreal manhattanLength() const;
+
+    bool isNull() const;
+
+    qreal x() const;
+    qreal y() const;
+    void setX(qreal x);
+    void setY(qreal y);
+
+    qreal &rx();
+    qreal &ry();
+
+    QPointF &operator+=(const QPointF &p);
+    QPointF &operator-=(const QPointF &p);
+    QPointF &operator*=(qreal c);
+    QPointF &operator/=(qreal c);
+
+    friend inline bool operator==(const QPointF &, const QPointF &);
+    friend inline bool operator!=(const QPointF &, const QPointF &);
+    friend inline const QPointF operator+(const QPointF &, const QPointF &);
+    friend inline const QPointF operator-(const QPointF &, const QPointF &);
+    friend inline const QPointF operator*(qreal, const QPointF &);
+    friend inline const QPointF operator*(const QPointF &, qreal);
+    friend inline const QPointF operator-(const QPointF &);
+    friend inline const QPointF operator/(const QPointF &, qreal);
+
+    QPoint toPoint() const;
+
+private:
+    friend class QMatrix;
+    friend class QTransform;
+
+    qreal xp;
+    qreal yp;
+};
+
+template <> class QTypeInfo<QPointF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPointF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPointF"; } };
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QPointF &);
+ QDataStream &operator>>(QDataStream &, QPointF &);
+
+
+
+
+
+
+inline QPointF::QPointF() : xp(0), yp(0) { }
+
+inline QPointF::QPointF(qreal xpos, qreal ypos) : xp(xpos), yp(ypos) { }
+
+inline QPointF::QPointF(const QPoint &p) : xp(p.x()), yp(p.y()) { }
+
+inline bool QPointF::isNull() const
+{
+    return qIsNull(xp) && qIsNull(yp);
+}
+
+inline qreal QPointF::x() const
+{
+    return xp;
+}
+
+inline qreal QPointF::y() const
+{
+    return yp;
+}
+
+inline void QPointF::setX(qreal xpos)
+{
+    xp = xpos;
+}
+
+inline void QPointF::setY(qreal ypos)
+{
+    yp = ypos;
+}
+
+inline qreal &QPointF::rx()
+{
+    return xp;
+}
+
+inline qreal &QPointF::ry()
+{
+    return yp;
+}
+
+inline QPointF &QPointF::operator+=(const QPointF &p)
+{
+    xp+=p.xp;
+    yp+=p.yp;
+    return *this;
+}
+
+inline QPointF &QPointF::operator-=(const QPointF &p)
+{
+    xp-=p.xp; yp-=p.yp; return *this;
+}
+
+inline QPointF &QPointF::operator*=(qreal c)
+{
+    xp*=c; yp*=c; return *this;
+}
+
+inline bool operator==(const QPointF &p1, const QPointF &p2)
+{
+    return qFuzzyIsNull(p1.xp - p2.xp) && qFuzzyIsNull(p1.yp - p2.yp);
+}
+
+inline bool operator!=(const QPointF &p1, const QPointF &p2)
+{
+    return !qFuzzyIsNull(p1.xp - p2.xp) || !qFuzzyIsNull(p1.yp - p2.yp);
+}
+
+inline const QPointF operator+(const QPointF &p1, const QPointF &p2)
+{
+    return QPointF(p1.xp+p2.xp, p1.yp+p2.yp);
+}
+
+inline const QPointF operator-(const QPointF &p1, const QPointF &p2)
+{
+    return QPointF(p1.xp-p2.xp, p1.yp-p2.yp);
+}
+
+inline const QPointF operator*(const QPointF &p, qreal c)
+{
+    return QPointF(p.xp*c, p.yp*c);
+}
+
+inline const QPointF operator*(qreal c, const QPointF &p)
+{
+    return QPointF(p.xp*c, p.yp*c);
+}
+
+inline const QPointF operator-(const QPointF &p)
+{
+    return QPointF(-p.xp, -p.yp);
+}
+
+inline QPointF &QPointF::operator/=(qreal c)
+{
+    xp/=c;
+    yp/=c;
+    return *this;
+}
+
+inline const QPointF operator/(const QPointF &p, qreal c)
+{
+    return QPointF(p.xp/c, p.yp/c);
+}
+
+inline QPoint QPointF::toPoint() const
+{
+    return QPoint(qRound(xp), qRound(yp));
+}
+
+
+ QDebug operator<<(QDebug d, const QPointF &p);
+
+
+
+
+
+# 47 "/usr/include/qt4/QtCore/qrect.h" 2
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QRect
+{
+public:
+    QRect() { x1 = y1 = 0; x2 = y2 = -1; }
+    QRect(const QPoint &topleft, const QPoint &bottomright);
+    QRect(const QPoint &topleft, const QSize &size);
+    QRect(int left, int top, int width, int height);
+
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+
+    int left() const;
+    int top() const;
+    int right() const;
+    int bottom() const;
+    QRect normalized() const;
+# 85 "/usr/include/qt4/QtCore/qrect.h"
+    int x() const;
+    int y() const;
+    void setLeft(int pos);
+    void setTop(int pos);
+    void setRight(int pos);
+    void setBottom(int pos);
+    void setX(int x);
+    void setY(int y);
+
+    void setTopLeft(const QPoint &p);
+    void setBottomRight(const QPoint &p);
+    void setTopRight(const QPoint &p);
+    void setBottomLeft(const QPoint &p);
+
+    QPoint topLeft() const;
+    QPoint bottomRight() const;
+    QPoint topRight() const;
+    QPoint bottomLeft() const;
+    QPoint center() const;
+
+    void moveLeft(int pos);
+    void moveTop(int pos);
+    void moveRight(int pos);
+    void moveBottom(int pos);
+    void moveTopLeft(const QPoint &p);
+    void moveBottomRight(const QPoint &p);
+    void moveTopRight(const QPoint &p);
+    void moveBottomLeft(const QPoint &p);
+    void moveCenter(const QPoint &p);
+
+    inline void translate(int dx, int dy);
+    inline void translate(const QPoint &p);
+    inline QRect translated(int dx, int dy) const;
+    inline QRect translated(const QPoint &p) const;
+
+    void moveTo(int x, int t);
+    void moveTo(const QPoint &p);
+
+
+
+
+
+
+    void setRect(int x, int y, int w, int h);
+    inline void getRect(int *x, int *y, int *w, int *h) const;
+
+    void setCoords(int x1, int y1, int x2, int y2);
+
+
+
+    inline void getCoords(int *x1, int *y1, int *x2, int *y2) const;
+
+    inline void adjust(int x1, int y1, int x2, int y2);
+    inline QRect adjusted(int x1, int y1, int x2, int y2) const;
+
+    QSize size() const;
+    int width() const;
+    int height() const;
+    void setWidth(int w);
+    void setHeight(int h);
+    void setSize(const QSize &s);
+
+    QRect operator|(const QRect &r) const;
+    QRect operator&(const QRect &r) const;
+    QRect& operator|=(const QRect &r);
+    QRect& operator&=(const QRect &r);
+
+    bool contains(const QPoint &p, bool proper=false) const;
+    bool contains(int x, int y) const;
+    bool contains(int x, int y, bool proper) const;
+    bool contains(const QRect &r, bool proper = false) const;
+    QRect unite(const QRect &r) const;
+    QRect united(const QRect &other) const;
+    QRect intersect(const QRect &r) const;
+    QRect intersected(const QRect &other) const;
+    bool intersects(const QRect &r) const;
+
+    friend inline bool operator==(const QRect &, const QRect &);
+    friend inline bool operator!=(const QRect &, const QRect &);
+
+
+
+
+
+
+
+private:
+
+    friend void qt_setCoords(QRect *r, int xp1, int yp1, int xp2, int yp2);
+# 182 "/usr/include/qt4/QtCore/qrect.h"
+    int x1;
+    int y1;
+    int x2;
+    int y2;
+
+
+};
+template <> class QTypeInfo<QRect > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRect)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRect"; } };
+
+ inline bool operator==(const QRect &, const QRect &);
+ inline bool operator!=(const QRect &, const QRect &);
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QRect &);
+ QDataStream &operator>>(QDataStream &, QRect &);
+
+
+
+
+
+
+inline QRect::QRect(int aleft, int atop, int awidth, int aheight)
+{
+    x1 = aleft;
+    y1 = atop;
+    x2 = (aleft + awidth - 1);
+    y2 = (atop + aheight - 1);
+}
+
+inline QRect::QRect(const QPoint &atopLeft, const QPoint &abottomRight)
+{
+    x1 = atopLeft.x();
+    y1 = atopLeft.y();
+    x2 = abottomRight.x();
+    y2 = abottomRight.y();
+}
+
+inline QRect::QRect(const QPoint &atopLeft, const QSize &asize)
+{
+    x1 = atopLeft.x();
+    y1 = atopLeft.y();
+    x2 = (x1+asize.width() - 1);
+    y2 = (y1+asize.height() - 1);
+}
+
+inline bool QRect::isNull() const
+{ return x2 == x1 - 1 && y2 == y1 - 1; }
+
+inline bool QRect::isEmpty() const
+{ return x1 > x2 || y1 > y2; }
+
+inline bool QRect::isValid() const
+{ return x1 <= x2 && y1 <= y2; }
+
+inline int QRect::left() const
+{ return x1; }
+
+inline int QRect::top() const
+{ return y1; }
+
+inline int QRect::right() const
+{ return x2; }
+
+inline int QRect::bottom() const
+{ return y2; }
+
+inline int QRect::x() const
+{ return x1; }
+
+inline int QRect::y() const
+{ return y1; }
+
+inline void QRect::setLeft(int pos)
+{ x1 = pos; }
+
+inline void QRect::setTop(int pos)
+{ y1 = pos; }
+
+inline void QRect::setRight(int pos)
+{ x2 = pos; }
+
+inline void QRect::setBottom(int pos)
+{ y2 = pos; }
+
+inline void QRect::setTopLeft(const QPoint &p)
+{ x1 = p.x(); y1 = p.y(); }
+
+inline void QRect::setBottomRight(const QPoint &p)
+{ x2 = p.x(); y2 = p.y(); }
+
+inline void QRect::setTopRight(const QPoint &p)
+{ x2 = p.x(); y1 = p.y(); }
+
+inline void QRect::setBottomLeft(const QPoint &p)
+{ x1 = p.x(); y2 = p.y(); }
+
+inline void QRect::setX(int ax)
+{ x1 = ax; }
+
+inline void QRect::setY(int ay)
+{ y1 = ay; }
+
+inline QPoint QRect::topLeft() const
+{ return QPoint(x1, y1); }
+
+inline QPoint QRect::bottomRight() const
+{ return QPoint(x2, y2); }
+
+inline QPoint QRect::topRight() const
+{ return QPoint(x2, y1); }
+
+inline QPoint QRect::bottomLeft() const
+{ return QPoint(x1, y2); }
+
+inline QPoint QRect::center() const
+{ return QPoint((x1+x2)/2, (y1+y2)/2); }
+
+inline int QRect::width() const
+{ return x2 - x1 + 1; }
+
+inline int QRect::height() const
+{ return y2 - y1 + 1; }
+
+inline QSize QRect::size() const
+{ return QSize(width(), height()); }
+
+inline void QRect::translate(int dx, int dy)
+{
+    x1 += dx;
+    y1 += dy;
+    x2 += dx;
+    y2 += dy;
+}
+
+inline void QRect::translate(const QPoint &p)
+{
+    x1 += p.x();
+    y1 += p.y();
+    x2 += p.x();
+    y2 += p.y();
+}
+
+inline QRect QRect::translated(int dx, int dy) const
+{ return QRect(QPoint(x1 + dx, y1 + dy), QPoint(x2 + dx, y2 + dy)); }
+
+inline QRect QRect::translated(const QPoint &p) const
+{ return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); }
+
+inline void QRect::moveTo(int ax, int ay)
+{
+    x2 += ax - x1;
+    y2 += ay - y1;
+    x1 = ax;
+    y1 = ay;
+}
+
+inline void QRect::moveTo(const QPoint &p)
+{
+    x2 += p.x() - x1;
+    y2 += p.y() - y1;
+    x1 = p.x();
+    y1 = p.y();
+}
+
+inline void QRect::moveLeft(int pos)
+{ x2 += (pos - x1); x1 = pos; }
+
+inline void QRect::moveTop(int pos)
+{ y2 += (pos - y1); y1 = pos; }
+
+inline void QRect::moveRight(int pos)
+{
+    x1 += (pos - x2);
+    x2 = pos;
+}
+
+inline void QRect::moveBottom(int pos)
+{
+    y1 += (pos - y2);
+    y2 = pos;
+}
+
+inline void QRect::moveTopLeft(const QPoint &p)
+{
+    moveLeft(p.x());
+    moveTop(p.y());
+}
+
+inline void QRect::moveBottomRight(const QPoint &p)
+{
+    moveRight(p.x());
+    moveBottom(p.y());
+}
+
+inline void QRect::moveTopRight(const QPoint &p)
+{
+    moveRight(p.x());
+    moveTop(p.y());
+}
+
+inline void QRect::moveBottomLeft(const QPoint &p)
+{
+    moveLeft(p.x());
+    moveBottom(p.y());
+}
+
+inline void QRect::getRect(int *ax, int *ay, int *aw, int *ah) const
+{
+    *ax = x1;
+    *ay = y1;
+    *aw = x2 - x1 + 1;
+    *ah = y2 - y1 + 1;
+}
+
+inline void QRect::setRect(int ax, int ay, int aw, int ah)
+{
+    x1 = ax;
+    y1 = ay;
+    x2 = (ax + aw - 1);
+    y2 = (ay + ah - 1);
+}
+
+inline void QRect::getCoords(int *xp1, int *yp1, int *xp2, int *yp2) const
+{
+    *xp1 = x1;
+    *yp1 = y1;
+    *xp2 = x2;
+    *yp2 = y2;
+}
+
+inline void QRect::setCoords(int xp1, int yp1, int xp2, int yp2)
+{
+    x1 = xp1;
+    y1 = yp1;
+    x2 = xp2;
+    y2 = yp2;
+}
+# 431 "/usr/include/qt4/QtCore/qrect.h"
+inline QRect QRect::adjusted(int xp1, int yp1, int xp2, int yp2) const
+{ return QRect(QPoint(x1 + xp1, y1 + yp1), QPoint(x2 + xp2, y2 + yp2)); }
+
+inline void QRect::adjust(int dx1, int dy1, int dx2, int dy2)
+{
+    x1 += dx1;
+    y1 += dy1;
+    x2 += dx2;
+    y2 += dy2;
+}
+
+inline void QRect::setWidth(int w)
+{ x2 = (x1 + w - 1); }
+
+inline void QRect::setHeight(int h)
+{ y2 = (y1 + h - 1); }
+
+inline void QRect::setSize(const QSize &s)
+{
+    x2 = (s.width() + x1 - 1);
+    y2 = (s.height() + y1 - 1);
+}
+
+inline bool QRect::contains(int ax, int ay, bool aproper) const
+{
+    return contains(QPoint(ax, ay), aproper);
+}
+
+inline bool QRect::contains(int ax, int ay) const
+{
+    return contains(QPoint(ax, ay), false);
+}
+
+inline QRect& QRect::operator|=(const QRect &r)
+{
+    *this = *this | r;
+    return *this;
+}
+
+inline QRect& QRect::operator&=(const QRect &r)
+{
+    *this = *this & r;
+    return *this;
+}
+
+inline QRect QRect::intersect(const QRect &r) const
+{
+    return *this & r;
+}
+
+inline QRect QRect::intersected(const QRect &other) const
+{
+    return intersect(other);
+}
+
+inline QRect QRect::unite(const QRect &r) const
+{
+    return *this | r;
+}
+
+inline QRect QRect::united(const QRect &r) const
+{
+     return unite(r);
+}
+
+inline bool operator==(const QRect &r1, const QRect &r2)
+{
+    return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2;
+}
+
+inline bool operator!=(const QRect &r1, const QRect &r2)
+{
+    return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2;
+}
+
+
+ QDebug operator<<(QDebug, const QRect &);
+
+
+
+class QRectF
+{
+public:
+    QRectF() { xp = yp = 0.; w = h = 0.; }
+    QRectF(const QPointF &topleft, const QSizeF &size);
+    QRectF(const QPointF &topleft, const QPointF &bottomRight);
+    QRectF(qreal left, qreal top, qreal width, qreal height);
+    QRectF(const QRect &rect);
+
+    bool isNull() const;
+    bool isEmpty() const;
+    bool isValid() const;
+    QRectF normalized() const;
+
+    inline qreal left() const { return xp; }
+    inline qreal top() const { return yp; }
+    inline qreal right() const { return xp + w; }
+    inline qreal bottom() const { return yp + h; }
+
+    inline qreal x() const;
+    inline qreal y() const;
+    inline void setLeft(qreal pos);
+    inline void setTop(qreal pos);
+    inline void setRight(qreal pos);
+    inline void setBottom(qreal pos);
+    inline void setX(qreal pos) { setLeft(pos); }
+    inline void setY(qreal pos) { setTop(pos); }
+
+    inline QPointF topLeft() const { return QPointF(xp, yp); }
+    inline QPointF bottomRight() const { return QPointF(xp+w, yp+h); }
+    inline QPointF topRight() const { return QPointF(xp+w, yp); }
+    inline QPointF bottomLeft() const { return QPointF(xp, yp+h); }
+    inline QPointF center() const;
+
+    void setTopLeft(const QPointF &p);
+    void setBottomRight(const QPointF &p);
+    void setTopRight(const QPointF &p);
+    void setBottomLeft(const QPointF &p);
+
+    void moveLeft(qreal pos);
+    void moveTop(qreal pos);
+    void moveRight(qreal pos);
+    void moveBottom(qreal pos);
+    void moveTopLeft(const QPointF &p);
+    void moveBottomRight(const QPointF &p);
+    void moveTopRight(const QPointF &p);
+    void moveBottomLeft(const QPointF &p);
+    void moveCenter(const QPointF &p);
+
+    void translate(qreal dx, qreal dy);
+    void translate(const QPointF &p);
+
+    QRectF translated(qreal dx, qreal dy) const;
+    QRectF translated(const QPointF &p) const;
+
+    void moveTo(qreal x, qreal t);
+    void moveTo(const QPointF &p);
+
+    void setRect(qreal x, qreal y, qreal w, qreal h);
+    void getRect(qreal *x, qreal *y, qreal *w, qreal *h) const;
+
+    void setCoords(qreal x1, qreal y1, qreal x2, qreal y2);
+    void getCoords(qreal *x1, qreal *y1, qreal *x2, qreal *y2) const;
+
+    inline void adjust(qreal x1, qreal y1, qreal x2, qreal y2);
+    inline QRectF adjusted(qreal x1, qreal y1, qreal x2, qreal y2) const;
+
+    QSizeF size() const;
+    qreal width() const;
+    qreal height() const;
+    void setWidth(qreal w);
+    void setHeight(qreal h);
+    void setSize(const QSizeF &s);
+
+    QRectF operator|(const QRectF &r) const;
+    QRectF operator&(const QRectF &r) const;
+    QRectF& operator|=(const QRectF &r);
+    QRectF& operator&=(const QRectF &r);
+
+    bool contains(const QPointF &p) const;
+    bool contains(qreal x, qreal y) const;
+    bool contains(const QRectF &r) const;
+    QRectF unite(const QRectF &r) const;
+    QRectF united(const QRectF &other) const;
+    QRectF intersect(const QRectF &r) const;
+    QRectF intersected(const QRectF &other) const;
+    bool intersects(const QRectF &r) const;
+
+    friend inline bool operator==(const QRectF &, const QRectF &);
+    friend inline bool operator!=(const QRectF &, const QRectF &);
+
+    QRect toRect() const;
+    QRect toAlignedRect() const;
+
+private:
+    qreal xp;
+    qreal yp;
+    qreal w;
+    qreal h;
+};
+template <> class QTypeInfo<QRectF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRectF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRectF"; } };
+
+ inline bool operator==(const QRectF &, const QRectF &);
+ inline bool operator!=(const QRectF &, const QRectF &);
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QRectF &);
+ QDataStream &operator>>(QDataStream &, QRectF &);
+
+
+
+
+
+
+inline QRectF::QRectF(qreal aleft, qreal atop, qreal awidth, qreal aheight)
+    : xp(aleft), yp(atop), w(awidth), h(aheight)
+{
+}
+
+inline QRectF::QRectF(const QPointF &atopLeft, const QSizeF &asize)
+{
+    xp = atopLeft.x();
+    yp = atopLeft.y();
+    w = asize.width();
+    h = asize.height();
+}
+
+inline QRectF::QRectF(const QPointF &atopLeft, const QPointF &abottomRight)
+{
+    xp = atopLeft.x();
+    yp = atopLeft.y();
+    w = abottomRight.x() - xp;
+    h = abottomRight.y() - yp;
+}
+
+inline QRectF::QRectF(const QRect &r)
+    : xp(r.x()), yp(r.y()), w(r.width()), h(r.height())
+{
+}
+
+inline bool QRectF::isNull() const
+{ return w == 0. && h == 0.; }
+
+inline bool QRectF::isEmpty() const
+{ return w <= 0. || h <= 0.; }
+
+inline bool QRectF::isValid() const
+{ return w > 0. && h > 0.; }
+
+inline qreal QRectF::x() const
+{ return xp; }
+
+inline qreal QRectF::y() const
+{ return yp; }
+
+inline void QRectF::setLeft(qreal pos) { qreal diff = pos - xp; xp += diff; w -= diff; }
+
+inline void QRectF::setRight(qreal pos) { w = pos - xp; }
+
+inline void QRectF::setTop(qreal pos) { qreal diff = pos - yp; yp += diff; h -= diff; }
+
+inline void QRectF::setBottom(qreal pos) { h = pos - yp; }
+
+inline void QRectF::setTopLeft(const QPointF &p) { setLeft(p.x()); setTop(p.y()); }
+
+inline void QRectF::setTopRight(const QPointF &p) { setRight(p.x()); setTop(p.y()); }
+
+inline void QRectF::setBottomLeft(const QPointF &p) { setLeft(p.x()); setBottom(p.y()); }
+
+inline void QRectF::setBottomRight(const QPointF &p) { setRight(p.x()); setBottom(p.y()); }
+
+inline QPointF QRectF::center() const
+{ return QPointF(xp + w/2, yp + h/2); }
+
+inline void QRectF::moveLeft(qreal pos) { xp = pos; }
+
+inline void QRectF::moveTop(qreal pos) { yp = pos; }
+
+inline void QRectF::moveRight(qreal pos) { xp = pos - w; }
+
+inline void QRectF::moveBottom(qreal pos) { yp = pos - h; }
+
+inline void QRectF::moveTopLeft(const QPointF &p) { moveLeft(p.x()); moveTop(p.y()); }
+
+inline void QRectF::moveTopRight(const QPointF &p) { moveRight(p.x()); moveTop(p.y()); }
+
+inline void QRectF::moveBottomLeft(const QPointF &p) { moveLeft(p.x()); moveBottom(p.y()); }
+
+inline void QRectF::moveBottomRight(const QPointF &p) { moveRight(p.x()); moveBottom(p.y()); }
+
+inline void QRectF::moveCenter(const QPointF &p) { xp = p.x() - w/2; yp = p.y() - h/2; }
+
+inline qreal QRectF::width() const
+{ return w; }
+
+inline qreal QRectF::height() const
+{ return h; }
+
+inline QSizeF QRectF::size() const
+{ return QSizeF(w, h); }
+
+inline void QRectF::translate(qreal dx, qreal dy)
+{
+    xp += dx;
+    yp += dy;
+}
+
+inline void QRectF::translate(const QPointF &p)
+{
+    xp += p.x();
+    yp += p.y();
+}
+
+inline void QRectF::moveTo(qreal ax, qreal ay)
+{
+    xp = ax;
+    yp = ay;
+}
+
+inline void QRectF::moveTo(const QPointF &p)
+{
+    xp = p.x();
+    yp = p.y();
+}
+
+inline QRectF QRectF::translated(qreal dx, qreal dy) const
+{ return QRectF(xp + dx, yp + dy, w, h); }
+
+inline QRectF QRectF::translated(const QPointF &p) const
+{ return QRectF(xp + p.x(), yp + p.y(), w, h); }
+
+inline void QRectF::getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) const
+{
+    *ax = this->xp;
+    *ay = this->yp;
+    *aaw = this->w;
+    *aah = this->h;
+}
+
+inline void QRectF::setRect(qreal ax, qreal ay, qreal aaw, qreal aah)
+{
+    this->xp = ax;
+    this->yp = ay;
+    this->w = aaw;
+    this->h = aah;
+}
+
+inline void QRectF::getCoords(qreal *xp1, qreal *yp1, qreal *xp2, qreal *yp2) const
+{
+    *xp1 = xp;
+    *yp1 = yp;
+    *xp2 = xp + w;
+    *yp2 = yp + h;
+}
+
+inline void QRectF::setCoords(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
+{
+    xp = xp1;
+    yp = yp1;
+    w = xp2 - xp1;
+    h = yp2 - yp1;
+}
+
+inline void QRectF::adjust(qreal xp1, qreal yp1, qreal xp2, qreal yp2)
+{ xp += xp1; yp += yp1; w += xp2 - xp1; h += yp2 - yp1; }
+
+inline QRectF QRectF::adjusted(qreal xp1, qreal yp1, qreal xp2, qreal yp2) const
+{ return QRectF(xp + xp1, yp + yp1, w + xp2 - xp1, h + yp2 - yp1); }
+
+inline void QRectF::setWidth(qreal aw)
+{ this->w = aw; }
+
+inline void QRectF::setHeight(qreal ah)
+{ this->h = ah; }
+
+inline void QRectF::setSize(const QSizeF &s)
+{
+    w = s.width();
+    h = s.height();
+}
+
+inline bool QRectF::contains(qreal ax, qreal ay) const
+{
+    return contains(QPointF(ax, ay));
+}
+
+inline QRectF& QRectF::operator|=(const QRectF &r)
+{
+    *this = *this | r;
+    return *this;
+}
+
+inline QRectF& QRectF::operator&=(const QRectF &r)
+{
+    *this = *this & r;
+    return *this;
+}
+
+inline QRectF QRectF::intersect(const QRectF &r) const
+{
+    return *this & r;
+}
+
+inline QRectF QRectF::intersected(const QRectF &r) const
+{
+    return intersect(r);
+}
+
+inline QRectF QRectF::unite(const QRectF &r) const
+{
+    return *this | r;
+}
+
+inline QRectF QRectF::united(const QRectF &r) const
+{
+    return unite(r);
+}
+
+inline bool operator==(const QRectF &r1, const QRectF &r2)
+{
+    return qFuzzyCompare(r1.xp, r2.xp) && qFuzzyCompare(r1.yp, r2.yp)
+           && qFuzzyCompare(r1.w, r2.w) && qFuzzyCompare(r1.h, r2.h);
+}
+
+inline bool operator!=(const QRectF &r1, const QRectF &r2)
+{
+    return !qFuzzyCompare(r1.xp, r2.xp) || !qFuzzyCompare(r1.yp, r2.yp)
+           || !qFuzzyCompare(r1.w, r2.w) || !qFuzzyCompare(r1.h, r2.h);
+}
+
+inline QRect QRectF::toRect() const
+{
+    return QRect(qRound(xp), qRound(yp), qRound(w), qRound(h));
+}
+
+
+ QDebug operator<<(QDebug, const QRectF &);
+
+
+
+
+
+# 47 "/usr/include/qt4/QtGui/qpaintdevice.h" 2
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+
+
+
+
+class QPaintEngine;
+
+class QPaintDevice
+{
+public:
+    enum PaintDeviceMetric {
+        PdmWidth = 1,
+        PdmHeight,
+        PdmWidthMM,
+        PdmHeightMM,
+        PdmNumColors,
+        PdmDepth,
+        PdmDpiX,
+        PdmDpiY,
+        PdmPhysicalDpiX,
+        PdmPhysicalDpiY
+    };
+
+    virtual ~QPaintDevice();
+
+    virtual int devType() const;
+    bool paintingActive() const;
+    virtual QPaintEngine *paintEngine() const = 0;
+# 91 "/usr/include/qt4/QtGui/qpaintdevice.h"
+    int width() const { return metric(PdmWidth); }
+    int height() const { return metric(PdmHeight); }
+    int widthMM() const { return metric(PdmWidthMM); }
+    int heightMM() const { return metric(PdmHeightMM); }
+    int logicalDpiX() const { return metric(PdmDpiX); }
+    int logicalDpiY() const { return metric(PdmDpiY); }
+    int physicalDpiX() const { return metric(PdmPhysicalDpiX); }
+    int physicalDpiY() const { return metric(PdmPhysicalDpiY); }
+
+    int numColors() const { return metric(PdmNumColors); }
+
+    int colorCount() const { return metric(PdmNumColors); }
+    int depth() const { return metric(PdmDepth); }
+
+public:
+    QPaintDevice();
+    virtual int metric(PaintDeviceMetric metric) const;
+
+    ushort painters;
+
+private:
+    QPaintDevice(const QPaintDevice &); QPaintDevice &operator=(const QPaintDevice &);
+# 140 "/usr/include/qt4/QtGui/qpaintdevice.h"
+    friend class QPainter;
+    friend class QFontEngineMac;
+    friend class QX11PaintEngine;
+    friend int qt_paint_device_metric(const QPaintDevice *device, PaintDeviceMetric metric);
+};
+# 167 "/usr/include/qt4/QtGui/qpaintdevice.h"
+inline int QPaintDevice::devType() const
+{ return QInternal::UnknownDevice; }
+
+inline bool QPaintDevice::paintingActive() const
+{ return painters != 0; }
+
+
+
+
+# 46 "/usr/include/qt4/QtGui/qpixmap.h" 2
+# 1 "/usr/include/qt4/QtGui/qcolor.h" 1
+# 45 "/usr/include/qt4/QtGui/qcolor.h"
+# 1 "/usr/include/qt4/QtGui/qrgb.h" 1
+# 47 "/usr/include/qt4/QtGui/qrgb.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+typedef unsigned int QRgb;
+
+const QRgb RGB_MASK = 0x00ffffff;
+
+ inline int qRed(QRgb rgb)
+{ return ((rgb >> 16) & 0xff); }
+
+ inline int qGreen(QRgb rgb)
+{ return ((rgb >> 8) & 0xff); }
+
+ inline int qBlue(QRgb rgb)
+{ return (rgb & 0xff); }
+
+ inline int qAlpha(QRgb rgb)
+{ return ((rgb >> 24) & 0xff); }
+
+ inline QRgb qRgb(int r, int g, int b)
+{ return (0xffu << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
+
+ inline QRgb qRgba(int r, int g, int b, int a)
+{ return ((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
+
+ inline int qGray(int r, int g, int b)
+{ return (r*11+g*16+b*5)/32; }
+
+ inline int qGray(QRgb rgb)
+{ return qGray(qRed(rgb), qGreen(rgb), qBlue(rgb)); }
+
+ inline bool qIsGray(QRgb rgb)
+{ return qRed(rgb) == qGreen(rgb) && qRed(rgb) == qBlue(rgb); }
+
+
+
+
+# 46 "/usr/include/qt4/QtGui/qcolor.h" 2
+
+# 1 "/usr/include/qt4/QtCore/qstringlist.h" 1
+# 45 "/usr/include/qt4/QtCore/qstringlist.h"
+# 1 "/usr/include/qt4/QtCore/qalgorithms.h" 1
+# 47 "/usr/include/qt4/QtCore/qalgorithms.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+
+
+
+
+namespace QAlgorithmsPrivate {
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
+template <typename RandomAccessIterator, typename T>
+inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy);
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qStableSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan);
+template <typename RandomAccessIterator, typename T>
+inline void qStableSortHelper(RandomAccessIterator, RandomAccessIterator, const T &);
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan);
+
+}
+
+template <typename InputIterator, typename OutputIterator>
+inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest)
+{
+    while (begin != end)
+        *dest++ = *begin++;
+    return dest;
+}
+
+template <typename BiIterator1, typename BiIterator2>
+inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest)
+{
+    while (begin != end)
+        *--dest = *--end;
+    return dest;
+}
+
+template <typename InputIterator1, typename InputIterator2>
+inline bool qEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
+{
+    for (; first1 != last1; ++first1, ++first2)
+        if (!(*first1 == *first2))
+            return false;
+    return true;
+}
+
+template <typename ForwardIterator, typename T>
+inline void qFill(ForwardIterator first, ForwardIterator last, const T &val)
+{
+    for (; first != last; ++first)
+        *first = val;
+}
+
+template <typename Container, typename T>
+inline void qFill(Container &container, const T &val)
+{
+    qFill(container.begin(), container.end(), val);
+}
+
+template <typename InputIterator, typename T>
+inline InputIterator qFind(InputIterator first, InputIterator last, const T &val)
+{
+    while (first != last && !(*first == val))
+        ++first;
+    return first;
+}
+
+template <typename Container, typename T>
+inline typename Container::const_iterator qFind(const Container &container, const T &val)
+{
+    return qFind(container.constBegin(), container.constEnd(), val);
+}
+
+template <typename InputIterator, typename T, typename Size>
+inline void qCount(InputIterator first, InputIterator last, const T &value, Size &n)
+{
+    for (; first != last; ++first)
+        if (*first == value)
+            ++n;
+}
+
+template <typename Container, typename T, typename Size>
+inline void qCount(const Container &container, const T &value, Size &n)
+{
+    qCount(container.constBegin(), container.constEnd(), value, n);
+}
+# 155 "/usr/include/qt4/QtCore/qalgorithms.h"
+template <typename T>
+class qLess
+{
+public:
+    inline bool operator()(const T &t1, const T &t2) const
+    {
+        return (t1 < t2);
+    }
+};
+
+template <typename T>
+class qGreater
+{
+public:
+    inline bool operator()(const T &t1, const T &t2) const
+    {
+        return (t2 < t1);
+    }
+};
+
+
+template <typename RandomAccessIterator>
+inline void qSort(RandomAccessIterator start, RandomAccessIterator end)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qSortHelper(start, end, *start);
+}
+
+template <typename RandomAccessIterator, typename LessThan>
+inline void qSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan);
+}
+
+template<typename Container>
+inline void qSort(Container &c)
+{
+
+
+
+
+    if (!c.empty())
+        QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin());
+}
+
+template <typename RandomAccessIterator>
+inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qStableSortHelper(start, end, *start);
+}
+
+template <typename RandomAccessIterator, typename LessThan>
+inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan)
+{
+    if (start != end)
+        QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan);
+}
+
+template<typename Container>
+inline void qStableSort(Container &c)
+{
+
+
+
+
+    if (!c.empty())
+        QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin());
+}
+
+template <typename RandomAccessIterator, typename T>
+ RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
+{
+
+
+
+    RandomAccessIterator middle;
+    int n = end - begin;
+    int half;
+
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (*middle < value) {
+            begin = middle + 1;
+            n -= half + 1;
+        } else {
+            n = half;
+        }
+    }
+    return begin;
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan);
+}
+
+template <typename Container, typename T>
+ typename Container::const_iterator qLowerBound(const Container &container, const T &value)
+{
+    return QAlgorithmsPrivate::qLowerBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
+}
+
+template <typename RandomAccessIterator, typename T>
+ RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
+{
+
+    RandomAccessIterator middle;
+    int n = end - begin;
+    int half;
+
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (value < *middle) {
+            n = half;
+        } else {
+            begin = middle + 1;
+            n -= half + 1;
+        }
+    }
+    return begin;
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan);
+}
+
+template <typename Container, typename T>
+ typename Container::const_iterator qUpperBound(const Container &container, const T &value)
+{
+    return QAlgorithmsPrivate::qUpperBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
+}
+
+template <typename RandomAccessIterator, typename T>
+ RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value)
+{
+
+    RandomAccessIterator it = qLowerBound(begin, end, value);
+
+    if (it == end || value < *it)
+        return end;
+
+    return it;
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan);
+}
+
+template <typename Container, typename T>
+ typename Container::const_iterator qBinaryFind(const Container &container, const T &value)
+{
+    return QAlgorithmsPrivate::qBinaryFindHelper(container.constBegin(), container.constEnd(), value, qLess<T>());
+}
+
+template <typename ForwardIterator>
+ void qDeleteAll(ForwardIterator begin, ForwardIterator end)
+{
+    while (begin != end) {
+        delete *begin;
+        ++begin;
+    }
+}
+
+template <typename Container>
+inline void qDeleteAll(const Container &c)
+{
+    qDeleteAll(c.begin(), c.end());
+}
+
+
+
+
+
+namespace QAlgorithmsPrivate {
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan)
+{
+top:
+    int span = int(end - start);
+    if (span < 2)
+        return;
+
+    --end;
+    RandomAccessIterator low = start, high = end - 1;
+    RandomAccessIterator pivot = start + span / 2;
+
+    if (lessThan(*end, *start))
+        qSwap(*end, *start);
+    if (span == 2)
+        return;
+
+    if (lessThan(*pivot, *start))
+        qSwap(*pivot, *start);
+    if (lessThan(*end, *pivot))
+        qSwap(*end, *pivot);
+    if (span == 3)
+        return;
+
+    qSwap(*pivot, *end);
+
+    while (low < high) {
+        while (low < high && lessThan(*low, *end))
+            ++low;
+
+        while (high > low && lessThan(*end, *high))
+            --high;
+
+        if (low < high) {
+            qSwap(*low, *high);
+            ++low;
+            --high;
+        } else {
+            break;
+        }
+    }
+
+    if (lessThan(*low, *end))
+        ++low;
+
+    qSwap(*end, *low);
+    qSortHelper(start, low, t, lessThan);
+
+    start = low + 1;
+    ++end;
+    goto top;
+}
+
+template <typename RandomAccessIterator, typename T>
+inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
+{
+    qSortHelper(begin, end, dummy, qLess<T>());
+}
+
+template <typename RandomAccessIterator>
+ void qReverse(RandomAccessIterator begin, RandomAccessIterator end)
+{
+    --end;
+    while (begin < end)
+        qSwap(*begin++, *end--);
+}
+
+template <typename RandomAccessIterator>
+ void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end)
+{
+    qReverse(begin, middle);
+    qReverse(middle, end);
+    qReverse(begin, end);
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qMerge(RandomAccessIterator begin, RandomAccessIterator pivot, RandomAccessIterator end, T &t, LessThan lessThan)
+{
+    const int len1 = pivot - begin;
+    const int len2 = end - pivot;
+
+    if (len1 == 0 || len2 == 0)
+        return;
+
+    if (len1 + len2 == 2) {
+        if (lessThan(*(begin + 1), *(begin)))
+            qSwap(*begin, *(begin + 1));
+        return;
+    }
+
+    RandomAccessIterator firstCut;
+    RandomAccessIterator secondCut;
+    int len2Half;
+    if (len1 > len2) {
+        const int len1Half = len1 / 2;
+        firstCut = begin + len1Half;
+        secondCut = qLowerBound(pivot, end, *firstCut, lessThan);
+        len2Half = secondCut - pivot;
+    } else {
+        len2Half = len2 / 2;
+        secondCut = pivot + len2Half;
+        firstCut = qUpperBound(begin, pivot, *secondCut, lessThan);
+    }
+
+    qRotate(firstCut, pivot, secondCut);
+    const RandomAccessIterator newPivot = firstCut + len2Half;
+    qMerge(begin, firstCut, newPivot, t, lessThan);
+    qMerge(newPivot, secondCut, end, t, lessThan);
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &t, LessThan lessThan)
+{
+    const int span = end - begin;
+    if (span < 2)
+       return;
+
+    const RandomAccessIterator middle = begin + span / 2;
+    qStableSortHelper(begin, middle, t, lessThan);
+    qStableSortHelper(middle, end, t, lessThan);
+    qMerge(begin, middle, end, t, lessThan);
+}
+
+template <typename RandomAccessIterator, typename T>
+inline void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy)
+{
+    qStableSortHelper(begin, end, dummy, qLess<T>());
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    RandomAccessIterator middle;
+    int n = int(end - begin);
+    int half;
+
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (lessThan(*middle, value)) {
+            begin = middle + 1;
+            n -= half + 1;
+        } else {
+            n = half;
+        }
+    }
+    return begin;
+}
+
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    RandomAccessIterator middle;
+    int n = end - begin;
+    int half;
+
+    while (n > 0) {
+        half = n >> 1;
+        middle = begin + half;
+        if (lessThan(value, *middle)) {
+            n = half;
+        } else {
+            begin = middle + 1;
+            n -= half + 1;
+        }
+    }
+    return begin;
+}
+
+template <typename RandomAccessIterator, typename T, typename LessThan>
+ RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan)
+{
+    RandomAccessIterator it = qLowerBoundHelper(begin, end, value, lessThan);
+
+    if (it == end || lessThan(value, *it))
+        return end;
+
+    return it;
+}
+
+}
+
+
+
+
+# 46 "/usr/include/qt4/QtCore/qstringlist.h" 2
+# 1 "/usr/include/qt4/QtCore/qdatastream.h" 1
+# 45 "/usr/include/qt4/QtCore/qdatastream.h"
+# 1 "/usr/include/qt4/QtCore/qscopedpointer.h" 1
+# 47 "/usr/include/qt4/QtCore/qscopedpointer.h"
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+template <typename T>
+struct QScopedPointerDeleter
+{
+    static inline void cleanup(T *pointer)
+    {
+
+
+
+        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
+        (void) sizeof(IsIncompleteType);
+
+        delete pointer;
+    }
+};
+
+template <typename T>
+struct QScopedPointerArrayDeleter
+{
+    static inline void cleanup(T *pointer)
+    {
+
+
+
+        typedef char IsIncompleteType[ sizeof(T) ? 1 : -1 ];
+        (void) sizeof(IsIncompleteType);
+
+        delete [] pointer;
+    }
+};
+
+struct QScopedPointerPodDeleter
+{
+    static inline void cleanup(void *pointer) { if (pointer) qFree(pointer); }
+};
+
+template <typename T, typename Cleanup = QScopedPointerDeleter<T> >
+class QScopedPointer
+{
+
+    typedef T *QScopedPointer:: *RestrictedBool;
+
+public:
+    explicit inline QScopedPointer(T *p = 0) : d(p)
+    {
+    }
+
+    inline ~QScopedPointer()
+    {
+        T *oldD = this->d;
+        Cleanup::cleanup(oldD);
+        this->d = 0;
+    }
+
+    inline T &operator*() const
+    {
+        ((!(d)) ? qt_assert("d","/usr/include/qt4/QtCore/qscopedpointer.h",106) : qt_noop());
+        return *d;
+    }
+
+    inline T *operator->() const
+    {
+        ((!(d)) ? qt_assert("d","/usr/include/qt4/QtCore/qscopedpointer.h",112) : qt_noop());
+        return d;
+    }
+
+    inline bool operator!() const
+    {
+        return !d;
+    }
+
+
+
+
+
+
+
+    inline operator RestrictedBool() const
+    {
+        return isNull() ? 0 : &QScopedPointer::d;
+    }
+
+
+    inline T *data() const
+    {
+        return d;
+    }
+
+    inline bool isNull() const
+    {
+        return !d;
+    }
+
+    inline void reset(T *other = 0)
+    {
+        if (d == other)
+            return;
+        T *oldD = d;
+        d = other;
+        Cleanup::cleanup(oldD);
+    }
+
+    inline T *take()
+    {
+        T *oldD = d;
+        d = 0;
+        return oldD;
+    }
+
+    inline void swap(QScopedPointer<T, Cleanup> &other)
+    {
+        qSwap(d, other.d);
+    }
+
+    typedef T *pointer;
+
+public:
+    T *d;
+
+private:
+    QScopedPointer(const QScopedPointer &); QScopedPointer &operator=(const QScopedPointer &);
+};
+
+template <class T, class Cleanup>
+inline bool operator==(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
+{
+    return lhs.data() == rhs.data();
+}
+
+template <class T, class Cleanup>
+inline bool operator!=(const QScopedPointer<T, Cleanup> &lhs, const QScopedPointer<T, Cleanup> &rhs)
+{
+    return lhs.data() != rhs.data();
+}
+
+template <class T, class Cleanup>
+inline void qSwap(QScopedPointer<T, Cleanup> &p1, QScopedPointer<T, Cleanup> &p2)
+{ p1.swap(p2); }
+
+template <typename T, typename Cleanup = QScopedPointerArrayDeleter<T> >
+class QScopedArrayPointer : public QScopedPointer<T, Cleanup>
+{
+public:
+    explicit inline QScopedArrayPointer(T *p = 0)
+        : QScopedPointer<T, Cleanup>(p)
+    {
+    }
+
+    inline T &operator[](int i)
+    {
+        return this->d[i];
+    }
+
+    inline const T &operator[](int i) const
+    {
+        return this->d[i];
+    }
+
+private:
+    QScopedArrayPointer(const QScopedArrayPointer &); QScopedArrayPointer &operator=(const QScopedArrayPointer &);
+};
+
+
+
+# 46 "/usr/include/qt4/QtCore/qdatastream.h" 2
+# 1 "/usr/include/qt4/QtCore/qiodevice.h" 1
+# 46 "/usr/include/qt4/QtCore/qiodevice.h"
+# 1 "/usr/include/qt4/QtCore/qobject.h" 1
+# 50 "/usr/include/qt4/QtCore/qobject.h"
+# 1 "/usr/include/qt4/QtCore/qlist.h" 1
+# 45 "/usr/include/qt4/QtCore/qlist.h"
+# 1 "/usr/include/qt4/QtCore/qiterator.h" 1
+# 47 "/usr/include/qt4/QtCore/qiterator.h"
+
+
+namespace std {
+    struct bidirectional_iterator_tag;
+    struct random_access_iterator_tag;
+}
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+# 198 "/usr/include/qt4/QtCore/qiterator.h"
+
+
+
+# 46 "/usr/include/qt4/QtCore/qlist.h" 2
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 1 3
+# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 3
+       
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+       
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 3
+       
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 3
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+  class locale
+  {
+  public:
+
+
+    typedef int category;
+
+
+    class facet;
+    class id;
+    class _Impl;
+
+    friend class facet;
+    friend class _Impl;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+# 98 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    static const category none = 0;
+    static const category ctype = 1L << 0;
+    static const category numeric = 1L << 1;
+    static const category collate = 1L << 2;
+    static const category time = 1L << 3;
+    static const category monetary = 1L << 4;
+    static const category messages = 1L << 5;
+    static const category all = (ctype | numeric | collate |
+        time | monetary | messages);
+# 117 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    locale() throw();
+# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    locale(const locale& __other) throw();
+# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    explicit
+    locale(const char* __s);
+# 151 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    locale(const locale& __base, const char* __s, category __cat);
+# 164 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    locale(const locale& __base, const locale& __add, category __cat);
+# 176 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale(const locale& __other, _Facet* __f);
+
+
+    ~locale() throw();
+# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    const locale&
+    operator=(const locale& __other) throw();
+# 205 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    template<typename _Facet>
+      locale
+      combine(const locale& __other) const;
+
+
+
+
+
+
+    string
+    name() const;
+# 224 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    bool
+    operator==(const locale& __other) const throw();
+
+
+
+
+
+
+
+    bool
+    operator!=(const locale& __other) const throw()
+    { return !(this->operator==(__other)); }
+# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    template<typename _Char, typename _Traits, typename _Alloc>
+      bool
+      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
+   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
+# 268 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    static locale
+    global(const locale&);
+
+
+
+
+    static const locale&
+    classic();
+
+  private:
+
+    _Impl* _M_impl;
+
+
+    static _Impl* _S_classic;
+
+
+    static _Impl* _S_global;
+
+
+
+
+
+    static const char* const* const _S_categories;
+# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    enum { _S_categories_size = 6 + 6 };
+
+
+    static __gthread_once_t _S_once;
+
+
+    explicit
+    locale(_Impl*) throw();
+
+    static void
+    _S_initialize();
+
+    static void
+    _S_initialize_once() throw();
+
+    static category
+    _S_normalize_category(category);
+
+    void
+    _M_coalesce(const locale& __base, const locale& __add, category __cat);
+  };
+# 337 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+  class locale::facet
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    mutable _Atomic_word _M_refcount;
+
+
+    static __c_locale _S_c_locale;
+
+
+    static const char _S_c_name[2];
+
+
+    static __gthread_once_t _S_once;
+
+
+    static void
+    _S_initialize_once();
+
+  public:
+# 368 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+    explicit
+    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
+    { }
+
+
+    virtual
+    ~facet();
+
+    static void
+    _S_create_c_locale(__c_locale& __cloc, const char* __s,
+         __c_locale __old = 0);
+
+    static __c_locale
+    _S_clone_c_locale(__c_locale& __cloc) throw();
+
+    static void
+    _S_destroy_c_locale(__c_locale& __cloc);
+
+    static __c_locale
+    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);
+
+
+
+    static __c_locale
+    _S_get_c_locale();
+
+    __attribute__ ((__const__)) static const char*
+    _S_get_c_name() throw();
+
+  private:
+    void
+    _M_add_reference() const throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() const throw()
+    {
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    facet(const facet&);
+
+    facet&
+    operator=(const facet&);
+  };
+# 432 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+  class locale::id
+  {
+  private:
+    friend class locale;
+    friend class locale::_Impl;
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+
+
+
+    mutable size_t _M_index;
+
+
+    static _Atomic_word _S_refcount;
+
+    void
+    operator=(const id&);
+
+    id(const id&);
+
+  public:
+
+
+
+    id() { }
+
+    size_t
+    _M_id() const throw();
+  };
+
+
+
+  class locale::_Impl
+  {
+  public:
+
+    friend class locale;
+    friend class locale::facet;
+
+    template<typename _Facet>
+      friend bool
+      has_facet(const locale&) throw();
+
+    template<typename _Facet>
+      friend const _Facet&
+      use_facet(const locale&);
+
+    template<typename _Cache>
+      friend struct __use_cache;
+
+  private:
+
+    _Atomic_word _M_refcount;
+    const facet** _M_facets;
+    size_t _M_facets_size;
+    const facet** _M_caches;
+    char** _M_names;
+    static const locale::id* const _S_id_ctype[];
+    static const locale::id* const _S_id_numeric[];
+    static const locale::id* const _S_id_collate[];
+    static const locale::id* const _S_id_time[];
+    static const locale::id* const _S_id_monetary[];
+    static const locale::id* const _S_id_messages[];
+    static const locale::id* const* const _S_facet_categories[];
+
+    void
+    _M_add_reference() throw()
+    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+    void
+    _M_remove_reference() throw()
+    {
+      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
+ {
+   try
+     { delete this; }
+   catch(...)
+     { }
+ }
+    }
+
+    _Impl(const _Impl&, size_t);
+    _Impl(const char*, size_t);
+    _Impl(size_t) throw();
+
+   ~_Impl() throw();
+
+    _Impl(const _Impl&);
+
+    void
+    operator=(const _Impl&);
+
+    bool
+    _M_check_same_name()
+    {
+      bool __ret = true;
+      if (_M_names[1])
+
+ for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
+   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
+      return __ret;
+    }
+
+    void
+    _M_replace_categories(const _Impl*, category);
+
+    void
+    _M_replace_category(const _Impl*, const locale::id* const*);
+
+    void
+    _M_replace_facet(const _Impl*, const locale::id*);
+
+    void
+    _M_install_facet(const locale::id*, const facet*);
+
+    template<typename _Facet>
+      void
+      _M_init_facet(_Facet* __facet)
+      { _M_install_facet(&_Facet::id, __facet); }
+
+    void
+    _M_install_cache(const facet*, size_t);
+  };
+# 575 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw();
+# 592 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc);
+# 609 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+  template<typename _CharT>
+    class collate : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+    public:
+
+
+      __c_locale _M_c_locale_collate;
+
+    public:
+
+      static locale::id id;
+# 636 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      explicit
+      collate(size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
+      { }
+# 650 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      explicit
+      collate(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
+      { }
+# 667 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      int
+      compare(const _CharT* __lo1, const _CharT* __hi1,
+       const _CharT* __lo2, const _CharT* __hi2) const
+      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
+# 686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      string_type
+      transform(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_transform(__lo, __hi); }
+# 700 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      long
+      hash(const _CharT* __lo, const _CharT* __hi) const
+      { return this->do_hash(__lo, __hi); }
+
+
+      int
+      _M_compare(const _CharT*, const _CharT*) const throw();
+
+      size_t
+      _M_transform(_CharT*, const _CharT*, size_t) const throw();
+
+  public:
+
+      virtual
+      ~collate()
+      { _S_destroy_c_locale(_M_c_locale_collate); }
+# 729 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      virtual int
+      do_compare(const _CharT* __lo1, const _CharT* __hi1,
+   const _CharT* __lo2, const _CharT* __hi2) const;
+# 745 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      virtual string_type
+      do_transform(const _CharT* __lo, const _CharT* __hi) const;
+# 758 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 3
+      virtual long
+      do_hash(const _CharT* __lo, const _CharT* __hi) const;
+    };
+
+  template<typename _CharT>
+    locale::id collate<_CharT>::id;
+
+
+  template<>
+    int
+    collate<char>::_M_compare(const char*, const char*) const throw();
+
+  template<>
+    size_t
+    collate<char>::_M_transform(char*, const char*, size_t) const throw();
+
+
+  template<>
+    int
+    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();
+
+  template<>
+    size_t
+    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();
+
+
+
+  template<typename _CharT>
+    class collate_byname : public collate<_CharT>
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+      explicit
+      collate_byname(const char* __s, size_t __refs = 0)
+      : collate<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_collate);
+     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
+   }
+      }
+
+    public:
+      virtual
+      ~collate_byname() { }
+    };
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.tcc" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.tcc" 3
+       
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Facet>
+    locale::
+    locale(const locale& __other, _Facet* __f)
+    {
+      _M_impl = new _Impl(*__other._M_impl, 1);
+
+      try
+ { _M_impl->_M_install_facet(&_Facet::id, __f); }
+      catch(...)
+ {
+   _M_impl->_M_remove_reference();
+   throw;
+ }
+      delete [] _M_impl->_M_names[0];
+      _M_impl->_M_names[0] = 0;
+    }
+
+  template<typename _Facet>
+    locale
+    locale::
+    combine(const locale& __other) const
+    {
+      _Impl* __tmp = new _Impl(*_M_impl, 1);
+      try
+ {
+   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
+ }
+      catch(...)
+ {
+   __tmp->_M_remove_reference();
+   throw;
+ }
+      return locale(__tmp);
+    }
+
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    bool
+    locale::
+    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
+        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
+    {
+      typedef std::collate<_CharT> __collate_type;
+      const __collate_type& __collate = use_facet<__collate_type>(*this);
+      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
+    __s2.data(), __s2.data() + __s2.length()) < 0);
+    }
+
+
+  template<typename _Facet>
+    bool
+    has_facet(const locale& __loc) throw()
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      return (__i < __loc._M_impl->_M_facets_size
+
+       && dynamic_cast<const _Facet*>(__facets[__i]));
+
+
+
+    }
+
+  template<typename _Facet>
+    const _Facet&
+    use_facet(const locale& __loc)
+    {
+      const size_t __i = _Facet::id._M_id();
+      const locale::facet** __facets = __loc._M_impl->_M_facets;
+      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
+        __throw_bad_cast();
+
+      return dynamic_cast<const _Facet&>(*__facets[__i]);
+
+
+
+    }
+
+
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
+    { return 0; }
+
+
+  template<typename _CharT>
+    size_t
+    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
+    { return 0; }
+
+  template<typename _CharT>
+    int
+    collate<_CharT>::
+    do_compare(const _CharT* __lo1, const _CharT* __hi1,
+        const _CharT* __lo2, const _CharT* __hi2) const
+    {
+
+
+      const string_type __one(__lo1, __hi1);
+      const string_type __two(__lo2, __hi2);
+
+      const _CharT* __p = __one.c_str();
+      const _CharT* __pend = __one.data() + __one.length();
+      const _CharT* __q = __two.c_str();
+      const _CharT* __qend = __two.data() + __two.length();
+
+
+
+
+      for (;;)
+ {
+   const int __res = _M_compare(__p, __q);
+   if (__res)
+     return __res;
+
+   __p += char_traits<_CharT>::length(__p);
+   __q += char_traits<_CharT>::length(__q);
+   if (__p == __pend && __q == __qend)
+     return 0;
+   else if (__p == __pend)
+     return -1;
+   else if (__q == __qend)
+     return 1;
+
+   __p++;
+   __q++;
+ }
+    }
+
+  template<typename _CharT>
+    typename collate<_CharT>::string_type
+    collate<_CharT>::
+    do_transform(const _CharT* __lo, const _CharT* __hi) const
+    {
+      string_type __ret;
+
+
+      const string_type __str(__lo, __hi);
+
+      const _CharT* __p = __str.c_str();
+      const _CharT* __pend = __str.data() + __str.length();
+
+      size_t __len = (__hi - __lo) * 2;
+
+      _CharT* __c = new _CharT[__len];
+
+      try
+ {
+
+
+
+   for (;;)
+     {
+
+       size_t __res = _M_transform(__c, __p, __len);
+
+
+       if (__res >= __len)
+  {
+    __len = __res + 1;
+    delete [] __c, __c = 0;
+    __c = new _CharT[__len];
+    __res = _M_transform(__c, __p, __len);
+  }
+
+       __ret.append(__c, __res);
+       __p += char_traits<_CharT>::length(__p);
+       if (__p == __pend)
+  break;
+
+       __p++;
+       __ret.push_back(_CharT());
+     }
+ }
+      catch(...)
+ {
+   delete [] __c;
+   throw;
+ }
+
+      delete [] __c;
+
+      return __ret;
+    }
+
+  template<typename _CharT>
+    long
+    collate<_CharT>::
+    do_hash(const _CharT* __lo, const _CharT* __hi) const
+    {
+      unsigned long __val = 0;
+      for (; __lo < __hi; ++__lo)
+ __val =
+   *__lo + ((__val << 7)
+     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
+    __digits - 7)));
+      return static_cast<long>(__val);
+    }
+
+
+
+
+
+  extern template class collate<char>;
+  extern template class collate_byname<char>;
+
+  extern template
+    const collate<char>&
+    use_facet<collate<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<char> >(const locale&);
+
+
+  extern template class collate<wchar_t>;
+  extern template class collate_byname<wchar_t>;
+
+  extern template
+    const collate<wchar_t>&
+    use_facet<collate<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<collate<wchar_t> >(const locale&);
+
+
+
+}
+# 816 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_classes.h" 2 3
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 2 3
+# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+  enum _Ios_Fmtflags
+    {
+      _S_boolalpha = 1L << 0,
+      _S_dec = 1L << 1,
+      _S_fixed = 1L << 2,
+      _S_hex = 1L << 3,
+      _S_internal = 1L << 4,
+      _S_left = 1L << 5,
+      _S_oct = 1L << 6,
+      _S_right = 1L << 7,
+      _S_scientific = 1L << 8,
+      _S_showbase = 1L << 9,
+      _S_showpoint = 1L << 10,
+      _S_showpos = 1L << 11,
+      _S_skipws = 1L << 12,
+      _S_unitbuf = 1L << 13,
+      _S_uppercase = 1L << 14,
+      _S_adjustfield = _S_left | _S_right | _S_internal,
+      _S_basefield = _S_dec | _S_oct | _S_hex,
+      _S_floatfield = _S_scientific | _S_fixed,
+      _S_ios_fmtflags_end = 1L << 16
+    };
+
+  inline _Ios_Fmtflags
+  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline _Ios_Fmtflags
+  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline _Ios_Fmtflags
+  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b)
+  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline _Ios_Fmtflags&
+  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a | __b; }
+
+  inline _Ios_Fmtflags&
+  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a & __b; }
+
+  inline _Ios_Fmtflags&
+  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b)
+  { return __a = __a ^ __b; }
+
+  inline _Ios_Fmtflags
+  operator~(_Ios_Fmtflags __a)
+  { return _Ios_Fmtflags(~static_cast<int>(__a)); }
+
+
+  enum _Ios_Openmode
+    {
+      _S_app = 1L << 0,
+      _S_ate = 1L << 1,
+      _S_bin = 1L << 2,
+      _S_in = 1L << 3,
+      _S_out = 1L << 4,
+      _S_trunc = 1L << 5,
+      _S_ios_openmode_end = 1L << 16
+    };
+
+  inline _Ios_Openmode
+  operator&(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline _Ios_Openmode
+  operator|(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline _Ios_Openmode
+  operator^(_Ios_Openmode __a, _Ios_Openmode __b)
+  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline _Ios_Openmode&
+  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a | __b; }
+
+  inline _Ios_Openmode&
+  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a & __b; }
+
+  inline _Ios_Openmode&
+  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b)
+  { return __a = __a ^ __b; }
+
+  inline _Ios_Openmode
+  operator~(_Ios_Openmode __a)
+  { return _Ios_Openmode(~static_cast<int>(__a)); }
+
+
+  enum _Ios_Iostate
+    {
+      _S_goodbit = 0,
+      _S_badbit = 1L << 0,
+      _S_eofbit = 1L << 1,
+      _S_failbit = 1L << 2,
+      _S_ios_iostate_end = 1L << 16
+    };
+
+  inline _Ios_Iostate
+  operator&(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }
+
+  inline _Ios_Iostate
+  operator|(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }
+
+  inline _Ios_Iostate
+  operator^(_Ios_Iostate __a, _Ios_Iostate __b)
+  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }
+
+  inline _Ios_Iostate&
+  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a | __b; }
+
+  inline _Ios_Iostate&
+  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a & __b; }
+
+  inline _Ios_Iostate&
+  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b)
+  { return __a = __a ^ __b; }
+
+  inline _Ios_Iostate
+  operator~(_Ios_Iostate __a)
+  { return _Ios_Iostate(~static_cast<int>(__a)); }
+
+  enum _Ios_Seekdir
+    {
+      _S_beg = 0,
+      _S_cur = 1,
+      _S_end = 2,
+      _S_ios_seekdir_end = 1L << 16
+    };
+# 207 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+  class ios_base
+  {
+  public:
+
+
+
+
+
+
+
+    class failure : public exception
+    {
+    public:
+
+
+      explicit
+      failure(const string& __str) throw();
+
+
+
+      virtual
+      ~failure() throw();
+
+      virtual const char*
+      what() const throw();
+
+    private:
+      string _M_msg;
+    };
+# 263 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    typedef _Ios_Fmtflags fmtflags;
+
+
+    static const fmtflags boolalpha = _S_boolalpha;
+
+
+    static const fmtflags dec = _S_dec;
+
+
+    static const fmtflags fixed = _S_fixed;
+
+
+    static const fmtflags hex = _S_hex;
+
+
+
+
+    static const fmtflags internal = _S_internal;
+
+
+
+    static const fmtflags left = _S_left;
+
+
+    static const fmtflags oct = _S_oct;
+
+
+
+    static const fmtflags right = _S_right;
+
+
+    static const fmtflags scientific = _S_scientific;
+
+
+
+    static const fmtflags showbase = _S_showbase;
+
+
+
+    static const fmtflags showpoint = _S_showpoint;
+
+
+    static const fmtflags showpos = _S_showpos;
+
+
+    static const fmtflags skipws = _S_skipws;
+
+
+    static const fmtflags unitbuf = _S_unitbuf;
+
+
+
+    static const fmtflags uppercase = _S_uppercase;
+
+
+    static const fmtflags adjustfield = _S_adjustfield;
+
+
+    static const fmtflags basefield = _S_basefield;
+
+
+    static const fmtflags floatfield = _S_floatfield;
+# 338 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    typedef _Ios_Iostate iostate;
+
+
+
+    static const iostate badbit = _S_badbit;
+
+
+    static const iostate eofbit = _S_eofbit;
+
+
+
+
+    static const iostate failbit = _S_failbit;
+
+
+    static const iostate goodbit = _S_goodbit;
+# 369 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    typedef _Ios_Openmode openmode;
+
+
+    static const openmode app = _S_app;
+
+
+    static const openmode ate = _S_ate;
+
+
+
+
+    static const openmode binary = _S_bin;
+
+
+    static const openmode in = _S_in;
+
+
+    static const openmode out = _S_out;
+
+
+    static const openmode trunc = _S_trunc;
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    typedef _Ios_Seekdir seekdir;
+
+
+    static const seekdir beg = _S_beg;
+
+
+    static const seekdir cur = _S_cur;
+
+
+    static const seekdir end = _S_end;
+
+
+    typedef int io_state;
+    typedef int open_mode;
+    typedef int seek_dir;
+
+    typedef std::streampos streampos;
+    typedef std::streamoff streamoff;
+# 427 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    enum event
+    {
+      erase_event,
+      imbue_event,
+      copyfmt_event
+    };
+# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    typedef void (*event_callback) (event, ios_base&, int);
+# 456 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    void
+    register_callback(event_callback __fn, int __index);
+
+  public:
+    streamsize _M_precision;
+    streamsize _M_width;
+    fmtflags _M_flags;
+    iostate _M_exception;
+    iostate _M_streambuf_state;
+
+
+
+    struct _Callback_list
+    {
+
+      _Callback_list* _M_next;
+      ios_base::event_callback _M_fn;
+      int _M_index;
+      _Atomic_word _M_refcount;
+
+      _Callback_list(ios_base::event_callback __fn, int __index,
+       _Callback_list* __cb)
+      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }
+
+      void
+      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }
+
+
+      int
+      _M_remove_reference()
+      { return __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); }
+    };
+
+     _Callback_list* _M_callbacks;
+
+    void
+    _M_call_callbacks(event __ev) throw();
+
+    void
+    _M_dispose_callbacks(void) throw();
+
+
+    struct _Words
+    {
+      void* _M_pword;
+      long _M_iword;
+      _Words() : _M_pword(0), _M_iword(0) { }
+    };
+
+
+    _Words _M_word_zero;
+
+
+
+    enum { _S_local_word_size = 8 };
+    _Words _M_local_word[_S_local_word_size];
+
+
+    int _M_word_size;
+    _Words* _M_word;
+
+    _Words&
+    _M_grow_words(int __index, bool __iword);
+
+
+    locale _M_ios_locale;
+
+    void
+    _M_init() throw();
+
+  public:
+
+
+
+
+
+    class Init
+    {
+      friend class ios_base;
+    public:
+      Init();
+      ~Init();
+
+    private:
+      static _Atomic_word _S_refcount;
+      static bool _S_synced_with_stdio;
+    };
+
+
+
+
+
+
+    fmtflags
+    flags() const
+    { return _M_flags; }
+# 560 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    fmtflags
+    flags(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags = __fmtfl;
+      return __old;
+    }
+# 576 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags |= __fmtfl;
+      return __old;
+    }
+# 593 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    fmtflags
+    setf(fmtflags __fmtfl, fmtflags __mask)
+    {
+      fmtflags __old = _M_flags;
+      _M_flags &= ~__mask;
+      _M_flags |= (__fmtfl & __mask);
+      return __old;
+    }
+
+
+
+
+
+
+
+    void
+    unsetf(fmtflags __mask)
+    { _M_flags &= ~__mask; }
+# 619 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    streamsize
+    precision() const
+    { return _M_precision; }
+
+
+
+
+
+
+    streamsize
+    precision(streamsize __prec)
+    {
+      streamsize __old = _M_precision;
+      _M_precision = __prec;
+      return __old;
+    }
+
+
+
+
+
+
+
+    streamsize
+    width() const
+    { return _M_width; }
+
+
+
+
+
+
+    streamsize
+    width(streamsize __wide)
+    {
+      streamsize __old = _M_width;
+      _M_width = __wide;
+      return __old;
+    }
+# 670 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    static bool
+    sync_with_stdio(bool __sync = true);
+# 682 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    locale
+    imbue(const locale& __loc) throw();
+# 693 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    locale
+    getloc() const
+    { return _M_ios_locale; }
+# 704 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    const locale&
+    _M_getloc() const
+    { return _M_ios_locale; }
+# 723 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    static int
+    xalloc() throw();
+# 739 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    long&
+    iword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, true);
+      return __word._M_iword;
+    }
+# 760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    void*&
+    pword(int __ix)
+    {
+      _Words& __word = (__ix < _M_word_size)
+   ? _M_word[__ix] : _M_grow_words(__ix, false);
+      return __word._M_pword;
+    }
+# 777 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ios_base.h" 3
+    virtual ~ios_base();
+
+  public:
+    ios_base() throw ();
+
+
+
+  private:
+    ios_base(const ios_base&);
+
+    ios_base&
+    operator=(const ios_base&);
+  };
+
+
+
+  inline ios_base&
+  boolalpha(ios_base& __base)
+  {
+    __base.setf(ios_base::boolalpha);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noboolalpha(ios_base& __base)
+  {
+    __base.unsetf(ios_base::boolalpha);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showbase(ios_base& __base)
+  {
+    __base.setf(ios_base::showbase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowbase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showbase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showpoint(ios_base& __base)
+  {
+    __base.setf(ios_base::showpoint);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowpoint(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpoint);
+    return __base;
+  }
+
+
+  inline ios_base&
+  showpos(ios_base& __base)
+  {
+    __base.setf(ios_base::showpos);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noshowpos(ios_base& __base)
+  {
+    __base.unsetf(ios_base::showpos);
+    return __base;
+  }
+
+
+  inline ios_base&
+  skipws(ios_base& __base)
+  {
+    __base.setf(ios_base::skipws);
+    return __base;
+  }
+
+
+  inline ios_base&
+  noskipws(ios_base& __base)
+  {
+    __base.unsetf(ios_base::skipws);
+    return __base;
+  }
+
+
+  inline ios_base&
+  uppercase(ios_base& __base)
+  {
+    __base.setf(ios_base::uppercase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  nouppercase(ios_base& __base)
+  {
+    __base.unsetf(ios_base::uppercase);
+    return __base;
+  }
+
+
+  inline ios_base&
+  unitbuf(ios_base& __base)
+  {
+     __base.setf(ios_base::unitbuf);
+     return __base;
+  }
+
+
+  inline ios_base&
+  nounitbuf(ios_base& __base)
+  {
+     __base.unsetf(ios_base::unitbuf);
+     return __base;
+  }
+
+
+
+  inline ios_base&
+  internal(ios_base& __base)
+  {
+     __base.setf(ios_base::internal, ios_base::adjustfield);
+     return __base;
+  }
+
+
+  inline ios_base&
+  left(ios_base& __base)
+  {
+    __base.setf(ios_base::left, ios_base::adjustfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  right(ios_base& __base)
+  {
+    __base.setf(ios_base::right, ios_base::adjustfield);
+    return __base;
+  }
+
+
+
+  inline ios_base&
+  dec(ios_base& __base)
+  {
+    __base.setf(ios_base::dec, ios_base::basefield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  hex(ios_base& __base)
+  {
+    __base.setf(ios_base::hex, ios_base::basefield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  oct(ios_base& __base)
+  {
+    __base.setf(ios_base::oct, ios_base::basefield);
+    return __base;
+  }
+
+
+
+  inline ios_base&
+  fixed(ios_base& __base)
+  {
+    __base.setf(ios_base::fixed, ios_base::floatfield);
+    return __base;
+  }
+
+
+  inline ios_base&
+  scientific(ios_base& __base)
+  {
+    __base.setf(ios_base::scientific, ios_base::floatfield);
+    return __base;
+  }
+
+}
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+       
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
+     basic_streambuf<_CharT, _Traits>*, bool&);
+# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+  template<typename _CharT, typename _Traits>
+    class basic_streambuf
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+
+
+      friend class basic_ios<char_type, traits_type>;
+      friend class basic_istream<char_type, traits_type>;
+      friend class basic_ostream<char_type, traits_type>;
+      friend class istreambuf_iterator<char_type, traits_type>;
+      friend class ostreambuf_iterator<char_type, traits_type>;
+
+      friend streamsize
+      __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&);
+
+      template<bool _IsMove, typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+        __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+      istreambuf_iterator<_CharT2> >::__type
+        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+
+      template<typename _CharT2, typename _Traits2>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        operator>>(basic_istream<_CharT2, _Traits2>&,
+     basic_string<_CharT2, _Traits2, _Alloc>&);
+
+      template<typename _CharT2, typename _Traits2, typename _Alloc>
+        friend basic_istream<_CharT2, _Traits2>&
+        getline(basic_istream<_CharT2, _Traits2>&,
+  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);
+
+    public:
+# 180 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      char_type* _M_in_beg;
+      char_type* _M_in_cur;
+      char_type* _M_in_end;
+      char_type* _M_out_beg;
+      char_type* _M_out_cur;
+      char_type* _M_out_end;
+
+
+      locale _M_buf_locale;
+
+  public:
+
+      virtual
+      ~basic_streambuf()
+      { }
+# 204 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      locale
+      pubimbue(const locale &__loc)
+      {
+ locale __tmp(this->getloc());
+ this->imbue(__loc);
+ _M_buf_locale = __loc;
+ return __tmp;
+      }
+# 221 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      locale
+      getloc() const
+      { return _M_buf_locale; }
+# 234 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      __streambuf_type*
+      pubsetbuf(char_type* __s, streamsize __n)
+      { return this->setbuf(__s, __n); }
+
+      pos_type
+      pubseekoff(off_type __off, ios_base::seekdir __way,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekoff(__off, __way, __mode); }
+
+      pos_type
+      pubseekpos(pos_type __sp,
+   ios_base::openmode __mode = ios_base::in | ios_base::out)
+      { return this->seekpos(__sp, __mode); }
+
+      int
+      pubsync() { return this->sync(); }
+# 261 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      streamsize
+      in_avail()
+      {
+ const streamsize __ret = this->egptr() - this->gptr();
+ return __ret ? __ret : this->showmanyc();
+      }
+# 275 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      int_type
+      snextc()
+      {
+ int_type __ret = traits_type::eof();
+ if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(),
+             __ret), true))
+   __ret = this->sgetc();
+ return __ret;
+      }
+# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      int_type
+      sbumpc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ else
+   __ret = this->uflow();
+ return __ret;
+      }
+# 315 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      int_type
+      sgetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->gptr() < this->egptr(), true))
+   __ret = traits_type::to_int_type(*this->gptr());
+ else
+   __ret = this->underflow();
+ return __ret;
+      }
+# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      streamsize
+      sgetn(char_type* __s, streamsize __n)
+      { return this->xsgetn(__s, __n); }
+# 349 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      int_type
+      sputbackc(char_type __c)
+      {
+ int_type __ret;
+ const bool __testpos = this->eback() < this->gptr();
+ if (__builtin_expect(!__testpos ||
+        !traits_type::eq(__c, this->gptr()[-1]), false))
+   __ret = this->pbackfail(traits_type::to_int_type(__c));
+ else
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ return __ret;
+      }
+# 374 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      int_type
+      sungetc()
+      {
+ int_type __ret;
+ if (__builtin_expect(this->eback() < this->gptr(), true))
+   {
+     this->gbump(-1);
+     __ret = traits_type::to_int_type(*this->gptr());
+   }
+ else
+   __ret = this->pbackfail();
+ return __ret;
+      }
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      int_type
+      sputc(char_type __c)
+      {
+ int_type __ret;
+ if (__builtin_expect(this->pptr() < this->epptr(), true))
+   {
+     *this->pptr() = __c;
+     this->pbump(1);
+     __ret = traits_type::to_int_type(__c);
+   }
+ else
+   __ret = this->overflow(traits_type::to_int_type(__c));
+ return __ret;
+      }
+# 427 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      streamsize
+      sputn(const char_type* __s, streamsize __n)
+      { return this->xsputn(__s, __n); }
+
+    public:
+# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      basic_streambuf()
+      : _M_in_beg(0), _M_in_cur(0), _M_in_end(0),
+      _M_out_beg(0), _M_out_cur(0), _M_out_end(0),
+      _M_buf_locale(locale())
+      { }
+# 459 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      char_type*
+      eback() const { return _M_in_beg; }
+
+      char_type*
+      gptr() const { return _M_in_cur; }
+
+      char_type*
+      egptr() const { return _M_in_end; }
+# 475 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      void
+      gbump(int __n) { _M_in_cur += __n; }
+# 486 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      void
+      setg(char_type* __gbeg, char_type* __gnext, char_type* __gend)
+      {
+ _M_in_beg = __gbeg;
+ _M_in_cur = __gnext;
+ _M_in_end = __gend;
+      }
+# 506 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      char_type*
+      pbase() const { return _M_out_beg; }
+
+      char_type*
+      pptr() const { return _M_out_cur; }
+
+      char_type*
+      epptr() const { return _M_out_end; }
+# 522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      void
+      pbump(int __n) { _M_out_cur += __n; }
+# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      void
+      setp(char_type* __pbeg, char_type* __pend)
+      {
+ _M_out_beg = _M_out_cur = __pbeg;
+ _M_out_end = __pend;
+      }
+# 553 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual void
+      imbue(const locale&)
+      { }
+# 568 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual basic_streambuf<char_type,_Traits>*
+      setbuf(char_type*, streamsize)
+      { return this; }
+# 579 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual pos_type
+      seekoff(off_type, ios_base::seekdir,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 591 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual pos_type
+      seekpos(pos_type,
+       ios_base::openmode = ios_base::in | ios_base::out)
+      { return pos_type(off_type(-1)); }
+# 604 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual int
+      sync() { return 0; }
+# 626 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual streamsize
+      showmanyc() { return 0; }
+# 642 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual streamsize
+      xsgetn(char_type* __s, streamsize __n);
+# 664 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual int_type
+      underflow()
+      { return traits_type::eof(); }
+# 677 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual int_type
+      uflow()
+      {
+ int_type __ret = traits_type::eof();
+ const bool __testeof = traits_type::eq_int_type(this->underflow(),
+       __ret);
+ if (!__testeof)
+   {
+     __ret = traits_type::to_int_type(*this->gptr());
+     this->gbump(1);
+   }
+ return __ret;
+      }
+# 701 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual int_type
+      pbackfail(int_type = traits_type::eof())
+      { return traits_type::eof(); }
+# 719 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual streamsize
+      xsputn(const char_type* __s, streamsize __n);
+# 745 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      virtual int_type
+      overflow(int_type = traits_type::eof())
+      { return traits_type::eof(); }
+
+
+
+    public:
+# 760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 3
+      void
+      stossc()
+      {
+ if (this->gptr() < this->egptr())
+   this->gbump(1);
+ else
+   this->uflow();
+      }
+
+
+    private:
+
+
+      basic_streambuf(const __streambuf_type& __sb)
+      : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur),
+      _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg),
+      _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur),
+      _M_buf_locale(__sb._M_buf_locale)
+      { }
+
+      __streambuf_type&
+      operator=(const __streambuf_type&) { return *this; };
+    };
+
+
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
+     basic_streambuf<char>* __sbout, bool& __ineof);
+
+  template<>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
+     basic_streambuf<wchar_t>* __sbout, bool& __ineof);
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf.tcc" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf.tcc" 3
+       
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsgetn(char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->egptr() - this->gptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(__s, this->gptr(), __len);
+       __ret += __len;
+       __s += __len;
+       this->gbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       const int_type __c = this->uflow();
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    traits_type::assign(*__s++, traits_type::to_char_type(__c));
+    ++__ret;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_streambuf<_CharT, _Traits>::
+    xsputn(const char_type* __s, streamsize __n)
+    {
+      streamsize __ret = 0;
+      while (__ret < __n)
+ {
+   const streamsize __buf_len = this->epptr() - this->pptr();
+   if (__buf_len)
+     {
+       const streamsize __remaining = __n - __ret;
+       const streamsize __len = std::min(__buf_len, __remaining);
+       traits_type::copy(this->pptr(), __s, __len);
+       __ret += __len;
+       __s += __len;
+       this->pbump(__len);
+     }
+
+   if (__ret < __n)
+     {
+       int_type __c = this->overflow(traits_type::to_int_type(*__s));
+       if (!traits_type::eq_int_type(__c, traits_type::eof()))
+  {
+    ++__ret;
+    ++__s;
+  }
+       else
+  break;
+     }
+ }
+      return __ret;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
+     basic_streambuf<_CharT, _Traits>* __sbout,
+     bool& __ineof)
+    {
+      streamsize __ret = 0;
+      __ineof = true;
+      typename _Traits::int_type __c = __sbin->sgetc();
+      while (!_Traits::eq_int_type(__c, _Traits::eof()))
+ {
+   __c = __sbout->sputc(_Traits::to_char_type(__c));
+   if (_Traits::eq_int_type(__c, _Traits::eof()))
+     {
+       __ineof = false;
+       break;
+     }
+   ++__ret;
+   __c = __sbin->snextc();
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline streamsize
+    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
+        basic_streambuf<_CharT, _Traits>* __sbout)
+    {
+      bool __ineof;
+      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
+    }
+
+
+
+
+
+  extern template class basic_streambuf<char>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<char>*,
+        basic_streambuf<char>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<char>*,
+     basic_streambuf<char>*, bool&);
+
+
+  extern template class basic_streambuf<wchar_t>;
+  extern template
+    streamsize
+    __copy_streambufs(basic_streambuf<wchar_t>*,
+        basic_streambuf<wchar_t>*);
+  extern template
+    streamsize
+    __copy_streambufs_eof(basic_streambuf<wchar_t>*,
+     basic_streambuf<wchar_t>*, bool&);
+
+
+
+}
+# 800 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/streambuf" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 1 3
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+       
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 3
+
+
+
+
+# 1 "/usr/include/wctype.h" 1 3 4
+# 34 "/usr/include/wctype.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 35 "/usr/include/wctype.h" 2 3 4
+# 50 "/usr/include/wctype.h" 3 4
+
+
+
+typedef unsigned long int wctype_t;
+
+# 72 "/usr/include/wctype.h" 3 4
+enum
+{
+  __ISwupper = 0,
+  __ISwlower = 1,
+  __ISwalpha = 2,
+  __ISwdigit = 3,
+  __ISwxdigit = 4,
+  __ISwspace = 5,
+  __ISwprint = 6,
+  __ISwgraph = 7,
+  __ISwblank = 8,
+  __ISwcntrl = 9,
+  __ISwpunct = 10,
+  __ISwalnum = 11,
+
+  _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))),
+  _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))),
+  _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))),
+  _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))),
+  _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))),
+  _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))),
+  _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))),
+  _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))),
+  _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))),
+  _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))),
+  _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))),
+  _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24))))
+};
+
+
+
+extern "C" {
+
+
+
+
+
+
+
+
+extern int iswalnum (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswalpha (wint_t __wc) throw ();
+
+
+extern int iswcntrl (wint_t __wc) throw ();
+
+
+
+extern int iswdigit (wint_t __wc) throw ();
+
+
+
+extern int iswgraph (wint_t __wc) throw ();
+
+
+
+
+extern int iswlower (wint_t __wc) throw ();
+
+
+extern int iswprint (wint_t __wc) throw ();
+
+
+
+
+extern int iswpunct (wint_t __wc) throw ();
+
+
+
+
+extern int iswspace (wint_t __wc) throw ();
+
+
+
+
+extern int iswupper (wint_t __wc) throw ();
+
+
+
+
+extern int iswxdigit (wint_t __wc) throw ();
+
+
+
+
+
+extern int iswblank (wint_t __wc) throw ();
+# 172 "/usr/include/wctype.h" 3 4
+extern wctype_t wctype (__const char *__property) throw ();
+
+
+
+extern int iswctype (wint_t __wc, wctype_t __desc) throw ();
+
+
+
+
+
+
+
+
+
+
+typedef __const __int32_t *wctrans_t;
+
+
+
+
+
+
+
+extern wint_t towlower (wint_t __wc) throw ();
+
+
+extern wint_t towupper (wint_t __wc) throw ();
+
+
+}
+# 214 "/usr/include/wctype.h" 3 4
+extern "C" {
+
+
+
+
+extern wctrans_t wctrans (__const char *__property) throw ();
+
+
+extern wint_t towctrans (wint_t __wc, wctrans_t __desc) throw ();
+
+
+
+
+
+
+
+
+extern int iswalnum_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+
+extern int iswalpha_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern int iswcntrl_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern int iswdigit_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern int iswgraph_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswlower_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern int iswprint_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswpunct_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswspace_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswupper_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswxdigit_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+
+extern int iswblank_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern wctype_t wctype_l (__const char *__property, __locale_t __locale)
+     throw ();
+
+
+
+extern int iswctype_l (wint_t __wc, wctype_t __desc, __locale_t __locale)
+     throw ();
+
+
+
+
+
+
+
+extern wint_t towlower_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+extern wint_t towupper_l (wint_t __wc, __locale_t __locale) throw ();
+
+
+
+extern wctrans_t wctrans_l (__const char *__property, __locale_t __locale)
+     throw ();
+
+
+extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
+      __locale_t __locale) throw ();
+
+
+
+}
+# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 2 3
+# 76 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cwctype" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::wctrans_t;
+  using ::wctype_t;
+  using ::wint_t;
+
+  using ::iswalnum;
+  using ::iswalpha;
+
+  using ::iswblank;
+
+  using ::iswcntrl;
+  using ::iswctype;
+  using ::iswdigit;
+  using ::iswgraph;
+  using ::iswlower;
+  using ::iswprint;
+  using ::iswpunct;
+  using ::iswspace;
+  using ::iswupper;
+  using ::iswxdigit;
+  using ::towctrans;
+  using ::towlower;
+  using ::towupper;
+  using ::wctrans;
+  using ::wctype;
+
+}
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cctype" 3
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_base.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  struct ctype_base
+  {
+
+    typedef const int* __to_type;
+
+
+
+    typedef unsigned short mask;
+    static const mask upper = _ISupper;
+    static const mask lower = _ISlower;
+    static const mask alpha = _ISalpha;
+    static const mask digit = _ISdigit;
+    static const mask xdigit = _ISxdigit;
+    static const mask space = _ISspace;
+    static const mask print = _ISprint;
+    static const mask graph = _ISalpha | _ISdigit | _ISpunct;
+    static const mask cntrl = _IScntrl;
+    static const mask punct = _ISpunct;
+    static const mask alnum = _ISalpha | _ISdigit;
+  };
+
+}
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 1 3
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 3
+       
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 49 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/streambuf_iterator.h" 3
+  template<typename _CharT, typename _Traits>
+    class istreambuf_iterator
+    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
+        _CharT*, _CharT&>
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef typename _Traits::int_type int_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+                      ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+
+      template<bool _IsMove, typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+            _CharT2*>::__type
+ __copy_move_a2(istreambuf_iterator<_CharT2>,
+         istreambuf_iterator<_CharT2>, _CharT2*);
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+               istreambuf_iterator<_CharT2> >::__type
+ find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      const _CharT2&);
+
+    private:
+
+
+
+
+
+
+
+      mutable streambuf_type* _M_sbuf;
+      mutable int_type _M_c;
+
+    public:
+
+      istreambuf_iterator() throw()
+      : _M_sbuf(0), _M_c(traits_type::eof()) { }
+
+
+      istreambuf_iterator(istream_type& __s) throw()
+      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }
+
+
+      istreambuf_iterator(streambuf_type* __s) throw()
+      : _M_sbuf(__s), _M_c(traits_type::eof()) { }
+
+
+
+
+      char_type
+      operator*() const
+      {
+
+
+
+
+
+
+
+ return traits_type::to_char_type(_M_get());
+      }
+
+
+      istreambuf_iterator&
+      operator++()
+      {
+
+
+                        ;
+ if (_M_sbuf)
+   {
+     _M_sbuf->sbumpc();
+     _M_c = traits_type::eof();
+   }
+ return *this;
+      }
+
+
+      istreambuf_iterator
+      operator++(int)
+      {
+
+
+                        ;
+
+ istreambuf_iterator __old = *this;
+ if (_M_sbuf)
+   {
+     __old._M_c = _M_sbuf->sbumpc();
+     _M_c = traits_type::eof();
+   }
+ return __old;
+      }
+
+
+
+
+
+      bool
+      equal(const istreambuf_iterator& __b) const
+      { return _M_at_eof() == __b._M_at_eof(); }
+
+    private:
+      int_type
+      _M_get() const
+      {
+ const int_type __eof = traits_type::eof();
+ int_type __ret = __eof;
+ if (_M_sbuf)
+   {
+     if (!traits_type::eq_int_type(_M_c, __eof))
+       __ret = _M_c;
+     else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()),
+            __eof))
+       _M_c = __ret;
+     else
+       _M_sbuf = 0;
+   }
+ return __ret;
+      }
+
+      bool
+      _M_at_eof() const
+      {
+ const int_type __eof = traits_type::eof();
+ return traits_type::eq_int_type(_M_get(), __eof);
+      }
+    };
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return __a.equal(__b); }
+
+  template<typename _CharT, typename _Traits>
+    inline bool
+    operator!=(const istreambuf_iterator<_CharT, _Traits>& __a,
+        const istreambuf_iterator<_CharT, _Traits>& __b)
+    { return !__a.equal(__b); }
+
+
+  template<typename _CharT, typename _Traits>
+    class ostreambuf_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+
+      template<typename _CharT2>
+ friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
+                      ostreambuf_iterator<_CharT2> >::__type
+ copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
+      ostreambuf_iterator<_CharT2>);
+
+    private:
+      streambuf_type* _M_sbuf;
+      bool _M_failed;
+
+    public:
+
+      ostreambuf_iterator(ostream_type& __s) throw ()
+      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }
+
+
+      ostreambuf_iterator(streambuf_type* __s) throw ()
+      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }
+
+
+      ostreambuf_iterator&
+      operator=(_CharT __c)
+      {
+ if (!_M_failed &&
+     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
+   _M_failed = true;
+ return *this;
+      }
+
+
+      ostreambuf_iterator&
+      operator*()
+      { return *this; }
+
+
+      ostreambuf_iterator&
+      operator++(int)
+      { return *this; }
+
+
+      ostreambuf_iterator&
+      operator++()
+      { return *this; }
+
+
+      bool
+      failed() const throw()
+      { return _M_failed; }
+
+      ostreambuf_iterator&
+      _M_put(const _CharT* __ws, streamsize __len)
+      {
+ if (__builtin_expect(!_M_failed, true)
+     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
+    false))
+   _M_failed = true;
+ return *this;
+      }
+    };
+
+
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+                           ostreambuf_iterator<_CharT> >::__type
+    copy(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last,
+  ostreambuf_iterator<_CharT> __result)
+    {
+      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
+ {
+   bool __ineof;
+   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
+   if (!__ineof)
+     __result._M_failed = true;
+ }
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+            ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(_CharT* __first, _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+        ostreambuf_iterator<_CharT> >::__type
+    __copy_move_a2(const _CharT* __first, const _CharT* __last,
+     ostreambuf_iterator<_CharT> __result)
+    {
+      const streamsize __num = __last - __first;
+      if (__num > 0)
+ __result._M_put(__first, __num);
+      return __result;
+    }
+
+  template<bool _IsMove, typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+            _CharT*>::__type
+    __copy_move_a2(istreambuf_iterator<_CharT> __first,
+     istreambuf_iterator<_CharT> __last, _CharT* __result)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof()))
+     {
+       const streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    traits_type::copy(__result, __sb->gptr(), __n);
+    __sb->gbump(__n);
+    __result += __n;
+    __c = __sb->underflow();
+  }
+       else
+  {
+    *__result++ = traits_type::to_char_type(__c);
+    __c = __sb->snextc();
+  }
+     }
+ }
+      return __result;
+    }
+
+  template<typename _CharT>
+    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
+          istreambuf_iterator<_CharT> >::__type
+    find(istreambuf_iterator<_CharT> __first,
+  istreambuf_iterator<_CharT> __last, const _CharT& __val)
+    {
+      typedef istreambuf_iterator<_CharT> __is_iterator_type;
+      typedef typename __is_iterator_type::traits_type traits_type;
+      typedef typename __is_iterator_type::streambuf_type streambuf_type;
+      typedef typename traits_type::int_type int_type;
+
+      if (__first._M_sbuf && !__last._M_sbuf)
+ {
+   const int_type __ival = traits_type::to_int_type(__val);
+   streambuf_type* __sb = __first._M_sbuf;
+   int_type __c = __sb->sgetc();
+   while (!traits_type::eq_int_type(__c, traits_type::eof())
+   && !traits_type::eq_int_type(__c, __ival))
+     {
+       streamsize __n = __sb->egptr() - __sb->gptr();
+       if (__n > 1)
+  {
+    const _CharT* __p = traits_type::find(__sb->gptr(),
+       __n, __val);
+    if (__p)
+      __n = __p - __sb->gptr();
+    __sb->gbump(__n);
+    __c = __sb->sgetc();
+  }
+       else
+  __c = __sb->snextc();
+     }
+
+   if (!traits_type::eq_int_type(__c, traits_type::eof()))
+     __first._M_c = __c;
+   else
+     __first._M_sbuf = 0;
+ }
+      return __first;
+    }
+
+
+
+}
+# 51 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<typename _Tp>
+    void
+    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+  template<>
+    void
+    __convert_to_v(const char*, float&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+  template<>
+    void
+    __convert_to_v(const char*, long double&, ios_base::iostate&,
+     const __c_locale&) throw();
+
+
+
+  template<typename _CharT, typename _Traits>
+    struct __pad
+    {
+      static void
+      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
+      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
+    };
+
+
+
+
+
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last);
+
+
+
+
+  template<typename _CharT>
+    inline
+    ostreambuf_iterator<_CharT>
+    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
+    {
+      __s._M_put(__ws, __len);
+      return __s;
+    }
+
+
+  template<typename _CharT, typename _OutIter>
+    inline
+    _OutIter
+    __write(_OutIter __s, const _CharT* __ws, int __len)
+    {
+      for (int __j = 0; __j < __len; __j++, ++__s)
+ *__s = __ws[__j];
+      return __s;
+    }
+# 142 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class __ctype_abstract_base : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef _CharT char_type;
+# 160 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      bool
+      is(mask __m, char_type __c) const
+      { return this->do_is(__m, __c); }
+# 177 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
+      { return this->do_is(__lo, __hi, __vec); }
+# 193 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_is(__m, __lo, __hi); }
+# 209 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
+      { return this->do_scan_not(__m, __lo, __hi); }
+# 223 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 252 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      { return this->do_widen(__c); }
+# 303 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      { return this->do_widen(__lo, __hi, __to); }
+# 322 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return this->do_narrow(__c, __dfault); }
+# 344 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+       char __dfault, char *__to) const
+      { return this->do_narrow(__lo, __hi, __dfault, __to); }
+
+    public:
+      explicit
+      __ctype_abstract_base(size_t __refs = 0): facet(__refs) { }
+
+      virtual
+      ~__ctype_abstract_base() { }
+# 369 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const = 0;
+# 388 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi,
+     mask* __vec) const = 0;
+# 407 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo,
+   const char_type* __hi) const = 0;
+# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const = 0;
+# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type) const = 0;
+# 461 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
+# 477 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type) const = 0;
+# 494 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
+# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char) const = 0;
+# 534 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi,
+        char_type* __dest) const = 0;
+# 556 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type, char __dfault) const = 0;
+# 580 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __dest) const = 0;
+    };
+# 603 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class ctype : public __ctype_abstract_base<_CharT>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename __ctype_abstract_base<_CharT>::mask mask;
+
+
+      static locale::id id;
+
+      explicit
+      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }
+
+   public:
+      virtual
+      ~ctype();
+
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+
+      virtual char_type
+      do_toupper(char_type __c) const;
+
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_tolower(char_type __c) const;
+
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+
+      virtual char_type
+      do_widen(char __c) const;
+
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __dest) const;
+    };
+
+  template<typename _CharT>
+    locale::id ctype<_CharT>::id;
+# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<>
+    class ctype<char> : public locale::facet, public ctype_base
+    {
+    public:
+
+
+      typedef char char_type;
+
+    public:
+
+      __c_locale _M_c_locale_ctype;
+      bool _M_del;
+      __to_type _M_toupper;
+      __to_type _M_tolower;
+      const mask* _M_table;
+      mutable char _M_widen_ok;
+      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
+      mutable char _M_narrow_ok;
+
+
+    public:
+
+      static locale::id id;
+
+      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
+# 709 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
+# 722 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
+     size_t __refs = 0);
+# 735 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      inline bool
+      is(mask __m, char __c) const;
+# 750 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      inline const char*
+      is(const char* __lo, const char* __hi, mask* __vec) const;
+# 764 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      inline const char*
+      scan_is(mask __m, const char* __lo, const char* __hi) const;
+# 778 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      inline const char*
+      scan_not(mask __m, const char* __lo, const char* __hi) const;
+# 793 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      toupper(char_type __c) const
+      { return this->do_toupper(__c); }
+# 810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      toupper(char_type *__lo, const char_type* __hi) const
+      { return this->do_toupper(__lo, __hi); }
+# 826 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      tolower(char_type __c) const
+      { return this->do_tolower(__c); }
+# 843 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      tolower(char_type* __lo, const char_type* __hi) const
+      { return this->do_tolower(__lo, __hi); }
+# 863 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      widen(char __c) const
+      {
+ if (_M_widen_ok)
+   return _M_widen[static_cast<unsigned char>(__c)];
+ this->_M_widen_init();
+ return this->do_widen(__c);
+      }
+# 890 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char*
+      widen(const char* __lo, const char* __hi, char_type* __to) const
+      {
+ if (_M_widen_ok == 1)
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_widen_ok)
+   _M_widen_init();
+ return this->do_widen(__lo, __hi, __to);
+      }
+# 921 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      {
+ if (_M_narrow[static_cast<unsigned char>(__c)])
+   return _M_narrow[static_cast<unsigned char>(__c)];
+ const char __t = do_narrow(__c, __dfault);
+ if (__t != __dfault)
+   _M_narrow[static_cast<unsigned char>(__c)] = __t;
+ return __t;
+      }
+# 954 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      const char_type*
+      narrow(const char_type* __lo, const char_type* __hi,
+      char __dfault, char *__to) const
+      {
+ if (__builtin_expect(_M_narrow_ok == 1, true))
+   {
+     __builtin_memcpy(__to, __lo, __hi - __lo);
+     return __hi;
+   }
+ if (!_M_narrow_ok)
+   _M_narrow_init();
+ return this->do_narrow(__lo, __hi, __dfault, __to);
+      }
+
+
+
+
+
+      const mask*
+      table() const throw()
+      { return _M_table; }
+
+
+      static const mask*
+      classic_table() throw();
+    public:
+
+
+
+
+
+
+
+      virtual
+      ~ctype();
+# 1003 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type) const;
+# 1020 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1036 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type) const;
+# 1053 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1073 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char __c) const
+      { return __c; }
+# 1096 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const
+      {
+ __builtin_memcpy(__dest, __lo, __hi - __lo);
+ return __hi;
+      }
+# 1122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type __c, char) const
+      { return __c; }
+# 1148 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char, char* __dest) const
+      {
+ __builtin_memcpy(__dest, __lo, __hi - __lo);
+ return __hi;
+      }
+
+    private:
+      void _M_narrow_init() const;
+      void _M_widen_init() const;
+    };
+# 1173 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<>
+    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
+    {
+    public:
+
+
+      typedef wchar_t char_type;
+      typedef wctype_t __wmask_type;
+
+    public:
+      __c_locale _M_c_locale_ctype;
+
+
+      bool _M_narrow_ok;
+      char _M_narrow[128];
+      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];
+
+
+      mask _M_bit[16];
+      __wmask_type _M_wmask[16];
+
+    public:
+
+
+      static locale::id id;
+# 1206 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      ctype(size_t __refs = 0);
+# 1217 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      ctype(__c_locale __cloc, size_t __refs = 0);
+
+    public:
+      __wmask_type
+      _M_convert_to_wmask(const mask __m) const throw();
+
+
+      virtual
+      ~ctype();
+# 1241 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual bool
+      do_is(mask __m, char_type __c) const;
+# 1260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
+# 1278 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
+# 1296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_scan_not(mask __m, const char_type* __lo,
+    const char_type* __hi) const;
+# 1313 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_toupper(char_type) const;
+# 1330 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_toupper(char_type* __lo, const char_type* __hi) const;
+# 1346 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_tolower(char_type) const;
+# 1363 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_tolower(char_type* __lo, const char_type* __hi) const;
+# 1383 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_widen(char) const;
+# 1405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char*
+      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;
+# 1428 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char
+      do_narrow(char_type, char __dfault) const;
+# 1454 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual const char_type*
+      do_narrow(const char_type* __lo, const char_type* __hi,
+  char __dfault, char* __dest) const;
+
+
+      void
+      _M_initialize_ctype() throw();
+    };
+
+
+
+  template<typename _CharT>
+    class ctype_byname : public ctype<_CharT>
+    {
+    public:
+      typedef typename ctype<_CharT>::mask mask;
+
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+    public:
+      virtual
+      ~ctype_byname() { };
+    };
+
+
+  template<>
+    class ctype_byname<char> : public ctype<char>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+    public:
+      virtual
+      ~ctype_byname();
+    };
+
+
+  template<>
+    class ctype_byname<wchar_t> : public ctype<wchar_t>
+    {
+    public:
+      explicit
+      ctype_byname(const char* __s, size_t __refs = 0);
+
+    public:
+      virtual
+      ~ctype_byname();
+    };
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/ctype_inline.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  bool
+  ctype<char>::
+  is(mask __m, char __c) const
+  { return _M_table[static_cast<unsigned char>(__c)] & __m; }
+
+  const char*
+  ctype<char>::
+  is(const char* __low, const char* __high, mask* __vec) const
+  {
+    while (__low < __high)
+      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
+    return __high;
+  }
+
+  const char*
+  ctype<char>::
+  scan_is(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
+      ++__low;
+    return __low;
+  }
+
+  const char*
+  ctype<char>::
+  scan_not(mask __m, const char* __low, const char* __high) const
+  {
+    while (__low < __high
+    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
+      ++__low;
+    return __low;
+  }
+
+}
+# 1510 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  class __num_base
+  {
+  public:
+
+
+    enum
+      {
+        _S_ominus,
+        _S_oplus,
+        _S_ox,
+        _S_oX,
+        _S_odigits,
+        _S_odigits_end = _S_odigits + 16,
+        _S_oudigits = _S_odigits_end,
+        _S_oudigits_end = _S_oudigits + 16,
+        _S_oe = _S_odigits + 14,
+        _S_oE = _S_oudigits + 14,
+ _S_oend = _S_oudigits_end
+      };
+
+
+
+
+
+
+    static const char* _S_atoms_out;
+
+
+
+    static const char* _S_atoms_in;
+
+    enum
+    {
+      _S_iminus,
+      _S_iplus,
+      _S_ix,
+      _S_iX,
+      _S_izero,
+      _S_ie = _S_izero + 14,
+      _S_iE = _S_izero + 20,
+      _S_iend = 26
+    };
+
+
+
+    static void
+    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
+  };
+
+  template<typename _CharT>
+    struct __numpunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      const _CharT* _M_truename;
+      size_t _M_truename_size;
+      const _CharT* _M_falsename;
+      size_t _M_falsename_size;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+
+
+
+
+
+      _CharT _M_atoms_out[__num_base::_S_oend];
+
+
+
+
+
+      _CharT _M_atoms_in[__num_base::_S_iend];
+
+      bool _M_allocated;
+
+      __numpunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
+      _M_truename(__null), _M_truename_size(0), _M_falsename(__null),
+      _M_falsename_size(0), _M_decimal_point(_CharT()),
+      _M_thousands_sep(_CharT()), _M_allocated(false)
+      { }
+
+      ~__numpunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __numpunct_cache&
+      operator=(const __numpunct_cache&);
+
+      explicit
+      __numpunct_cache(const __numpunct_cache&);
+    };
+
+  template<typename _CharT>
+    __numpunct_cache<_CharT>::~__numpunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_truename;
+   delete [] _M_falsename;
+ }
+    }
+# 1635 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<typename _CharT>
+    class numpunct : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      typedef __numpunct_cache<_CharT> __cache_type;
+
+    public:
+      __cache_type* _M_data;
+
+    public:
+
+      static locale::id id;
+
+
+
+
+
+
+      explicit
+      numpunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
+      { _M_initialize_numpunct(); }
+# 1672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      numpunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_numpunct(); }
+# 1686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      numpunct(__c_locale __cloc, size_t __refs = 0)
+      : facet(__refs), _M_data(__null)
+      { _M_initialize_numpunct(__cloc); }
+# 1700 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1713 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1744 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1757 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      string_type
+      truename() const
+      { return this->do_truename(); }
+# 1770 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      string_type
+      falsename() const
+      { return this->do_falsename(); }
+
+    public:
+
+      virtual
+      ~numpunct();
+# 1787 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1799 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1812 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1825 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual string_type
+      do_truename() const
+      { return _M_data->_M_truename; }
+# 1838 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual string_type
+      do_falsename() const
+      { return _M_data->_M_falsename; }
+
+
+      void
+      _M_initialize_numpunct(__c_locale __cloc = __null);
+    };
+
+  template<typename _CharT>
+    locale::id numpunct<_CharT>::id;
+
+  template<>
+    numpunct<char>::~numpunct();
+
+  template<>
+    void
+    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+  template<>
+    numpunct<wchar_t>::~numpunct();
+
+  template<>
+    void
+    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);
+
+
+
+  template<typename _CharT>
+    class numpunct_byname : public numpunct<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      explicit
+      numpunct_byname(const char* __s, size_t __refs = 0)
+      : numpunct<_CharT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_numpunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+
+    public:
+      virtual
+      ~numpunct_byname() { }
+    };
+
+
+# 1908 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<typename _CharT, typename _InIter>
+    class num_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+
+
+      static locale::id id;
+# 1929 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      num_get(size_t __refs = 0) : facet(__refs) { }
+# 1955 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, bool& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 1991 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned short& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned int& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, unsigned long long& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2050 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, float& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, long double& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+# 2092 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      get(iter_type __in, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, void*& __v) const
+      { return this->do_get(__in, __end, __io, __err, __v); }
+
+    public:
+
+      virtual ~num_get() { }
+
+      iter_type
+      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         string&) const;
+
+      template<typename _ValueT>
+        iter_type
+        _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
+         _ValueT&) const;
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
+        _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
+        {
+   int __ret = -1;
+   if (__len <= 10)
+     {
+       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
+  __ret = __c - _CharT2('0');
+     }
+   else
+     {
+       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
+  __ret = __c - _CharT2('0');
+       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
+  __ret = 10 + (__c - _CharT2('a'));
+       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
+  __ret = 10 + (__c - _CharT2('A'));
+     }
+   return __ret;
+ }
+
+      template<typename _CharT2>
+      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
+          int>::__type
+        _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
+        {
+   int __ret = -1;
+   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
+   if (__q)
+     {
+       __ret = __q - __zero;
+       if (__ret > 15)
+  __ret -= 6;
+     }
+   return __ret;
+ }
+# 2163 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned short& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned int& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+      virtual iter_type
+      do_get(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, unsigned long long& __v) const
+      { return _M_extract_int(__beg, __end, __io, __err, __v); }
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      float&) const;
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      double&) const;
+
+
+
+
+
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      long double&) const;
+
+
+      virtual iter_type
+      do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err,
+      void*&) const;
+# 2228 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id num_get<_CharT, _InIter>::id;
+# 2246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+  template<typename _CharT, typename _OutIter>
+    class num_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 2267 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      explicit
+      num_put(size_t __refs = 0) : facet(__refs) { }
+# 2285 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+# 2327 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   unsigned long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+
+
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   unsigned long long __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+# 2390 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill, double __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   long double __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+# 2415 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __f, char_type __fill,
+   const void* __v) const
+      { return this->do_put(__s, __f, __fill, __v); }
+
+    public:
+      template<typename _ValueT>
+        iter_type
+        _M_insert_float(iter_type, ios_base& __io, char_type __fill,
+   char __mod, _ValueT __v) const;
+
+      void
+      _M_group_float(const char* __grouping, size_t __grouping_size,
+       char_type __sep, const char_type* __p, char_type* __new,
+       char_type* __cs, int& __len) const;
+
+      template<typename _ValueT>
+        iter_type
+        _M_insert_int(iter_type, ios_base& __io, char_type __fill,
+        _ValueT __v) const;
+
+      void
+      _M_group_int(const char* __grouping, size_t __grouping_size,
+     char_type __sep, ios_base& __io, char_type* __new,
+     char_type* __cs, int& __len) const;
+
+      void
+      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
+      char_type* __new, const char_type* __cs, int& __len) const;
+
+
+      virtual
+      ~num_put() { };
+# 2463 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 3
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, bool __v) const;
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill,
+      unsigned long long __v) const
+      { return _M_insert_int(__s, __io, __fill, __v); }
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, double __v) const;
+
+
+
+
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, long double __v) const;
+
+
+      virtual iter_type
+      do_put(iter_type, ios_base&, char_type __fill, const void* __v) const;
+
+
+
+
+
+
+
+    };
+
+  template <typename _CharT, typename _OutIter>
+    locale::id num_put<_CharT, _OutIter>::id;
+
+
+
+
+
+
+
+
+
+  template<typename _CharT>
+    inline bool
+    isspace(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isprint(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    iscntrl(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    islower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalpha(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    ispunct(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isxdigit(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isalnum(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }
+
+
+  template<typename _CharT>
+    inline bool
+    isgraph(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }
+
+
+  template<typename _CharT>
+    inline _CharT
+    toupper(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }
+
+
+  template<typename _CharT>
+    inline _CharT
+    tolower(_CharT __c, const locale& __loc)
+    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 1 3
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+       
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+  template<typename _Facet>
+    struct __use_cache
+    {
+      const _Facet*
+      operator() (const locale& __loc) const;
+    };
+
+
+  template<typename _CharT>
+    struct __use_cache<__numpunct_cache<_CharT> >
+    {
+      const __numpunct_cache<_CharT>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = numpunct<_CharT>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __numpunct_cache<_CharT>* __tmp = __null;
+     try
+       {
+  __tmp = new __numpunct_cache<_CharT>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT>
+    void
+    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
+    {
+      _M_allocated = true;
+
+      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);
+
+      char* __grouping = 0;
+      _CharT* __truename = 0;
+      _CharT* __falsename = 0;
+      try
+ {
+   _M_grouping_size = __np.grouping().size();
+   __grouping = new char[_M_grouping_size];
+   __np.grouping().copy(__grouping, _M_grouping_size);
+   _M_grouping = __grouping;
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(_M_grouping[0]) > 0
+        && (_M_grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+
+   _M_truename_size = __np.truename().size();
+   __truename = new _CharT[_M_truename_size];
+   __np.truename().copy(__truename, _M_truename_size);
+   _M_truename = __truename;
+
+   _M_falsename_size = __np.falsename().size();
+   __falsename = new _CharT[_M_falsename_size];
+   __np.falsename().copy(__falsename, _M_falsename_size);
+   _M_falsename = __falsename;
+
+   _M_decimal_point = __np.decimal_point();
+   _M_thousands_sep = __np.thousands_sep();
+
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(__num_base::_S_atoms_out,
+       __num_base::_S_atoms_out
+       + __num_base::_S_oend, _M_atoms_out);
+   __ct.widen(__num_base::_S_atoms_in,
+       __num_base::_S_atoms_in
+       + __num_base::_S_iend, _M_atoms_in);
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __truename;
+   delete [] __falsename;
+   throw;
+ }
+    }
+# 136 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+  __attribute__ ((__pure__)) bool
+  __verify_grouping(const char* __grouping, size_t __grouping_size,
+      const string& __grouping_tmp) throw ();
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, string& __xtrc) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      typedef __numpunct_cache<_CharT> __cache_type;
+      __use_cache<__cache_type> __uc;
+      const locale& __loc = __io._M_getloc();
+      const __cache_type* __lc = __uc(__loc);
+      const _CharT* __lit = __lc->_M_atoms_in;
+      char_type __c = char_type();
+
+
+      bool __testeof = __beg == __end;
+
+
+      if (!__testeof)
+ {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+     {
+       __xtrc += __plus ? '+' : '-';
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ }
+
+
+      bool __found_mantissa = false;
+      int __sep_pos = 0;
+      while (!__testeof)
+ {
+   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       || __c == __lc->_M_decimal_point)
+     break;
+   else if (__c == __lit[__num_base::_S_izero])
+     {
+       if (!__found_mantissa)
+  {
+    __xtrc += '0';
+    __found_mantissa = true;
+  }
+       ++__sep_pos;
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+   else
+     break;
+ }
+
+
+      bool __found_dec = false;
+      bool __found_sci = false;
+      string __found_grouping;
+      if (__lc->_M_use_grouping)
+ __found_grouping.reserve(32);
+      const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+      if (!__lc->_M_allocated)
+
+ while (!__testeof)
+   {
+     const int __digit = _M_find(__lit_zero, 10, __c);
+     if (__digit != -1)
+       {
+  __xtrc += '0' + __digit;
+  __found_mantissa = true;
+       }
+     else if (__c == __lc->_M_decimal_point
+       && !__found_dec && !__found_sci)
+       {
+  __xtrc += '.';
+  __found_dec = true;
+       }
+     else if ((__c == __lit[__num_base::_S_ie]
+        || __c == __lit[__num_base::_S_iE])
+       && !__found_sci && __found_mantissa)
+       {
+
+  __xtrc += 'e';
+  __found_sci = true;
+
+
+  if (++__beg != __end)
+    {
+      __c = *__beg;
+      const bool __plus = __c == __lit[__num_base::_S_iplus];
+      if (__plus || __c == __lit[__num_base::_S_iminus])
+        __xtrc += __plus ? '+' : '-';
+      else
+        continue;
+    }
+  else
+    {
+      __testeof = true;
+      break;
+    }
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+      else
+ while (!__testeof)
+   {
+
+
+     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+
+
+      if (__sep_pos)
+        {
+   __found_grouping += static_cast<char>(__sep_pos);
+   __sep_pos = 0;
+        }
+      else
+        {
+
+
+   __xtrc.clear();
+   break;
+        }
+    }
+  else
+    break;
+       }
+     else if (__c == __lc->_M_decimal_point)
+       {
+  if (!__found_dec && !__found_sci)
+    {
+
+
+
+      if (__found_grouping.size())
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += '.';
+      __found_dec = true;
+    }
+  else
+    break;
+       }
+     else
+       {
+  const char_type* __q =
+    __traits_type::find(__lit_zero, 10, __c);
+  if (__q)
+    {
+      __xtrc += '0' + (__q - __lit_zero);
+      __found_mantissa = true;
+      ++__sep_pos;
+    }
+  else if ((__c == __lit[__num_base::_S_ie]
+     || __c == __lit[__num_base::_S_iE])
+    && !__found_sci && __found_mantissa)
+    {
+
+      if (__found_grouping.size() && !__found_dec)
+        __found_grouping += static_cast<char>(__sep_pos);
+      __xtrc += 'e';
+      __found_sci = true;
+
+
+      if (++__beg != __end)
+        {
+   __c = *__beg;
+   const bool __plus = __c == __lit[__num_base::_S_iplus];
+   if ((__plus || __c == __lit[__num_base::_S_iminus])
+       && !(__lc->_M_use_grouping
+     && __c == __lc->_M_thousands_sep)
+       && !(__c == __lc->_M_decimal_point))
+        __xtrc += __plus ? '+' : '-';
+   else
+     continue;
+        }
+      else
+        {
+   __testeof = true;
+   break;
+        }
+    }
+  else
+    break;
+       }
+
+     if (++__beg != __end)
+       __c = *__beg;
+     else
+       __testeof = true;
+   }
+
+
+
+      if (__found_grouping.size())
+        {
+
+   if (!__found_dec && !__found_sci)
+     __found_grouping += static_cast<char>(__sep_pos);
+
+          if (!std::__verify_grouping(__lc->_M_grouping,
+          __lc->_M_grouping_size,
+          __found_grouping))
+     __err = ios_base::failbit;
+        }
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    template<typename _ValueT>
+      _InIter
+      num_get<_CharT, _InIter>::
+      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
+       ios_base::iostate& __err, _ValueT& __v) const
+      {
+        typedef char_traits<_CharT> __traits_type;
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_in;
+ char_type __c = char_type();
+
+
+ const ios_base::fmtflags __basefield = __io.flags()
+                                        & ios_base::basefield;
+ const bool __oct = __basefield == ios_base::oct;
+ int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);
+
+
+ bool __testeof = __beg == __end;
+
+
+ bool __negative = false;
+ if (!__testeof)
+   {
+     __c = *__beg;
+     __negative = __c == __lit[__num_base::_S_iminus];
+     if ((__negative || __c == __lit[__num_base::_S_iplus])
+  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  && !(__c == __lc->_M_decimal_point))
+       {
+  if (++__beg != __end)
+    __c = *__beg;
+  else
+    __testeof = true;
+       }
+   }
+
+
+
+ bool __found_zero = false;
+ int __sep_pos = 0;
+ while (!__testeof)
+   {
+     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  || __c == __lc->_M_decimal_point)
+       break;
+     else if (__c == __lit[__num_base::_S_izero]
+       && (!__found_zero || __base == 10))
+       {
+  __found_zero = true;
+  ++__sep_pos;
+  if (__basefield == 0)
+    __base = 8;
+  if (__base == 8)
+    __sep_pos = 0;
+       }
+     else if (__found_zero
+       && (__c == __lit[__num_base::_S_ix]
+    || __c == __lit[__num_base::_S_iX]))
+       {
+  if (__basefield == 0)
+    __base = 16;
+  if (__base == 16)
+    {
+      __found_zero = false;
+      __sep_pos = 0;
+    }
+  else
+    break;
+       }
+     else
+       break;
+
+     if (++__beg != __end)
+       {
+  __c = *__beg;
+  if (!__found_zero)
+    break;
+       }
+     else
+       __testeof = true;
+   }
+
+
+
+ const size_t __len = (__base == 16 ? __num_base::_S_iend
+         - __num_base::_S_izero : __base);
+
+
+ string __found_grouping;
+ if (__lc->_M_use_grouping)
+   __found_grouping.reserve(32);
+ bool __testfail = false;
+ bool __testoverflow = false;
+ const __unsigned_type __max =
+   (__negative && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+   ? -__gnu_cxx::__numeric_traits<_ValueT>::__min
+   : __gnu_cxx::__numeric_traits<_ValueT>::__max;
+ const __unsigned_type __smax = __max / __base;
+ __unsigned_type __result = 0;
+ int __digit = 0;
+ const char_type* __lit_zero = __lit + __num_base::_S_izero;
+
+ if (!__lc->_M_allocated)
+
+   while (!__testeof)
+     {
+       __digit = _M_find(__lit_zero, __len, __c);
+       if (__digit == -1)
+  break;
+
+       if (__result > __smax)
+  __testoverflow = true;
+       else
+  {
+    __result *= __base;
+    __testoverflow |= __result > __max - __digit;
+    __result += __digit;
+    ++__sep_pos;
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+ else
+   while (!__testeof)
+     {
+
+
+       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
+  {
+
+
+    if (__sep_pos)
+      {
+        __found_grouping += static_cast<char>(__sep_pos);
+        __sep_pos = 0;
+      }
+    else
+      {
+        __testfail = true;
+        break;
+      }
+  }
+       else if (__c == __lc->_M_decimal_point)
+  break;
+       else
+  {
+    const char_type* __q =
+      __traits_type::find(__lit_zero, __len, __c);
+    if (!__q)
+      break;
+
+    __digit = __q - __lit_zero;
+    if (__digit > 15)
+      __digit -= 6;
+    if (__result > __smax)
+      __testoverflow = true;
+    else
+      {
+        __result *= __base;
+        __testoverflow |= __result > __max - __digit;
+        __result += __digit;
+        ++__sep_pos;
+      }
+  }
+
+       if (++__beg != __end)
+  __c = *__beg;
+       else
+  __testeof = true;
+     }
+
+
+
+ if (__found_grouping.size())
+   {
+
+     __found_grouping += static_cast<char>(__sep_pos);
+
+     if (!std::__verify_grouping(__lc->_M_grouping,
+     __lc->_M_grouping_size,
+     __found_grouping))
+       __err = ios_base::failbit;
+   }
+
+
+
+ if ((!__sep_pos && !__found_zero && !__found_grouping.size())
+     || __testfail)
+   {
+     __v = 0;
+     __err = ios_base::failbit;
+   }
+ else if (__testoverflow)
+   {
+     if (__negative
+  && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__min;
+     else
+       __v = __gnu_cxx::__numeric_traits<_ValueT>::__max;
+     __err = ios_base::failbit;
+   }
+ else
+   __v = __negative ? -__result : __result;
+
+ if (__testeof)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, bool& __v) const
+    {
+      if (!(__io.flags() & ios_base::boolalpha))
+        {
+
+
+
+   long __l = -1;
+          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
+   if (__l == 0 || __l == 1)
+     __v = bool(__l);
+   else
+     {
+
+
+       __v = true;
+       __err = ios_base::failbit;
+       if (__beg == __end)
+  __err |= ios_base::eofbit;
+     }
+        }
+      else
+        {
+
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   bool __testf = true;
+   bool __testt = true;
+   bool __donef = __lc->_M_falsename_size == 0;
+   bool __donet = __lc->_M_truename_size == 0;
+   bool __testeof = false;
+   size_t __n = 0;
+   while (!__donef || !__donet)
+     {
+       if (__beg == __end)
+  {
+    __testeof = true;
+    break;
+  }
+
+       const char_type __c = *__beg;
+
+       if (!__donef)
+  __testf = __c == __lc->_M_falsename[__n];
+
+       if (!__testf && __donet)
+  break;
+
+       if (!__donet)
+  __testt = __c == __lc->_M_truename[__n];
+
+       if (!__testt && __donef)
+  break;
+
+       if (!__testt && !__testf)
+  break;
+
+       ++__n;
+       ++__beg;
+
+       __donef = !__testf || __n >= __lc->_M_falsename_size;
+       __donet = !__testt || __n >= __lc->_M_truename_size;
+     }
+   if (__testf && __n == __lc->_M_falsename_size && __n)
+     {
+       __v = false;
+       if (__testt && __n == __lc->_M_truename_size)
+  __err = ios_base::failbit;
+       else
+  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else if (__testt && __n == __lc->_M_truename_size && __n)
+     {
+       __v = true;
+       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
+     }
+   else
+     {
+
+
+       __v = false;
+       __err = ios_base::failbit;
+       if (__testeof)
+  __err |= ios_base::eofbit;
+     }
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, float& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+# 730 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, long double& __v) const
+    {
+      string __xtrc;
+      __xtrc.reserve(32);
+      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
+      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    num_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, ios_base& __io,
+           ios_base::iostate& __err, void*& __v) const
+    {
+
+      typedef ios_base::fmtflags fmtflags;
+      const fmtflags __fmt = __io.flags();
+      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      _UIntPtrType __ul;
+      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);
+
+
+      __io.flags(__fmt);
+
+      __v = reinterpret_cast<void*>(__ul);
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
+    _CharT* __new, const _CharT* __cs, int& __len) const
+    {
+
+
+      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
+        __cs, __w, __len);
+      __len = static_cast<int>(__w);
+    }
+
+
+
+  template<typename _CharT, typename _ValueT>
+    int
+    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
+    ios_base::fmtflags __flags, bool __dec)
+    {
+      _CharT* __buf = __bufend;
+      if (__builtin_expect(__dec, true))
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
+       __v /= 10;
+     }
+   while (__v != 0);
+ }
+      else if ((__flags & ios_base::basefield) == ios_base::oct)
+ {
+
+   do
+     {
+       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
+       __v >>= 3;
+     }
+   while (__v != 0);
+ }
+      else
+ {
+
+   const bool __uppercase = __flags & ios_base::uppercase;
+   const int __case_offset = __uppercase ? __num_base::_S_oudigits
+                                         : __num_base::_S_odigits;
+   do
+     {
+       *--__buf = __lit[(__v & 0xf) + __case_offset];
+       __v >>= 4;
+     }
+   while (__v != 0);
+ }
+      return __bufend - __buf;
+    }
+
+
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
+   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
+    {
+      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
+     __grouping_size, __cs, __cs + __len);
+      __len = __p - __new;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
+      _ValueT __v) const
+      {
+ using __gnu_cxx::__add_unsigned;
+ typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+ const _CharT* __lit = __lc->_M_atoms_out;
+ const ios_base::fmtflags __flags = __io.flags();
+
+
+ const int __ilen = 5 * sizeof(_ValueT);
+ _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __ilen));
+
+
+
+ const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
+ const bool __dec = (__basefield != ios_base::oct
+       && __basefield != ios_base::hex);
+ const __unsigned_type __u = ((__v > 0 || !__dec)
+         ? __unsigned_type(__v)
+         : -__unsigned_type(__v));
+  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
+ __cs += __ilen - __len;
+
+
+ if (__lc->_M_use_grouping)
+   {
+
+
+     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * (__len + 1)
+          * 2));
+     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
+    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
+     __cs = __cs2 + 2;
+   }
+
+
+ if (__builtin_expect(__dec, true))
+   {
+
+     if (__v >= 0)
+       {
+  if (bool(__flags & ios_base::showpos)
+      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
+    *--__cs = __lit[__num_base::_S_oplus], ++__len;
+       }
+     else
+       *--__cs = __lit[__num_base::_S_ominus], ++__len;
+   }
+ else if (bool(__flags & ios_base::showbase) && __v)
+   {
+     if (__basefield == ios_base::oct)
+       *--__cs = __lit[__num_base::_S_odigits], ++__len;
+     else
+       {
+
+  const bool __uppercase = __flags & ios_base::uppercase;
+  *--__cs = __lit[__num_base::_S_ox + __uppercase];
+
+  *--__cs = __lit[__num_base::_S_odigits];
+  __len += 2;
+       }
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
+     __cs = __cs3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __cs, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    void
+    num_put<_CharT, _OutIter>::
+    _M_group_float(const char* __grouping, size_t __grouping_size,
+     _CharT __sep, const _CharT* __p, _CharT* __new,
+     _CharT* __cs, int& __len) const
+    {
+
+
+
+      const int __declen = __p ? __p - __cs : __len;
+      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
+      __grouping_size,
+      __cs, __cs + __declen);
+
+
+      int __newlen = __p2 - __new;
+      if (__p)
+ {
+   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
+   __newlen += __len - __declen;
+ }
+      __len = __newlen;
+    }
+# 966 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    template<typename _ValueT>
+      _OutIter
+      num_put<_CharT, _OutIter>::
+      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
+         _ValueT __v) const
+      {
+ typedef __numpunct_cache<_CharT> __cache_type;
+ __use_cache<__cache_type> __uc;
+ const locale& __loc = __io._M_getloc();
+ const __cache_type* __lc = __uc(__loc);
+
+
+ const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();
+
+ const int __max_digits =
+   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;
+
+
+ int __len;
+
+ char __fbuf[16];
+ __num_base::_S_format_float(__io, __fbuf, __mod);
+
+
+
+
+ int __cs_size = __max_digits * 3;
+ char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+ __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+          __fbuf, __prec, __v);
+
+
+ if (__len >= __cs_size)
+   {
+     __cs_size = __len + 1;
+     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+     __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+       __fbuf, __prec, __v);
+   }
+# 1027 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+            * __len));
+ __ctype.widen(__cs, __cs + __len, __ws);
+
+
+ _CharT* __wp = 0;
+ const char* __p = char_traits<char>::find(__cs, __len, '.');
+ if (__p)
+   {
+     __wp = __ws + (__p - __cs);
+     *__wp = __lc->_M_decimal_point;
+   }
+
+
+
+
+ if (__lc->_M_use_grouping
+     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
+          && __cs[1] >= '0' && __cs[2] >= '0')))
+   {
+
+
+     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __len * 2));
+
+     streamsize __off = 0;
+     if (__cs[0] == '-' || __cs[0] == '+')
+       {
+  __off = 1;
+  __ws2[0] = __ws[0];
+  __len -= 1;
+       }
+
+     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
+      __lc->_M_thousands_sep, __wp, __ws2 + __off,
+      __ws + __off, __len);
+     __len += __off;
+
+     __ws = __ws2;
+   }
+
+
+ const streamsize __w = __io.width();
+ if (__w > static_cast<streamsize>(__len))
+   {
+     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+          * __w));
+     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
+     __ws = __ws3;
+   }
+ __io.width(0);
+
+
+
+ return std::__write(__s, __ws, __len);
+      }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      if ((__flags & ios_base::boolalpha) == 0)
+        {
+          const long __l = __v;
+          __s = _M_insert_int(__s, __io, __fill, __l);
+        }
+      else
+        {
+   typedef __numpunct_cache<_CharT> __cache_type;
+   __use_cache<__cache_type> __uc;
+   const locale& __loc = __io._M_getloc();
+   const __cache_type* __lc = __uc(__loc);
+
+   const _CharT* __name = __v ? __lc->_M_truename
+                              : __lc->_M_falsename;
+   int __len = __v ? __lc->_M_truename_size
+                   : __lc->_M_falsename_size;
+
+   const streamsize __w = __io.width();
+   if (__w > static_cast<streamsize>(__len))
+     {
+       const streamsize __plen = __w - __len;
+       _CharT* __ps
+  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
+       * __plen));
+
+       char_traits<_CharT>::assign(__ps, __plen, __fill);
+       __io.width(0);
+
+       if ((__flags & ios_base::adjustfield) == ios_base::left)
+  {
+    __s = std::__write(__s, __name, __len);
+    __s = std::__write(__s, __ps, __plen);
+  }
+       else
+  {
+    __s = std::__write(__s, __ps, __plen);
+    __s = std::__write(__s, __name, __len);
+  }
+       return __s;
+     }
+   __io.width(0);
+   __s = std::__write(__s, __name, __len);
+ }
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
+    { return _M_insert_float(__s, __io, __fill, char(), __v); }
+# 1152 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+    long double __v) const
+    { return _M_insert_float(__s, __io, __fill, 'L', __v); }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    num_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type __fill,
+           const void* __v) const
+    {
+      const ios_base::fmtflags __flags = __io.flags();
+      const ios_base::fmtflags __fmt = ~(ios_base::basefield
+      | ios_base::uppercase);
+      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));
+
+      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
+          <= sizeof(unsigned long)),
+ unsigned long, unsigned long long>::__type _UIntPtrType;
+
+      __s = _M_insert_int(__s, __io, __fill,
+     reinterpret_cast<_UIntPtrType>(__v));
+      __io.flags(__flags);
+      return __s;
+    }
+
+
+# 1189 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.tcc" 3
+  template<typename _CharT, typename _Traits>
+    void
+    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
+       _CharT* __news, const _CharT* __olds,
+       streamsize __newlen, streamsize __oldlen)
+    {
+      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
+      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;
+
+
+      if (__adjust == ios_base::left)
+ {
+   _Traits::copy(__news, __olds, __oldlen);
+   _Traits::assign(__news + __oldlen, __plen, __fill);
+   return;
+ }
+
+      size_t __mod = 0;
+      if (__adjust == ios_base::internal)
+ {
+
+
+
+          const locale& __loc = __io._M_getloc();
+   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+   if (__ctype.widen('-') == __olds[0]
+       || __ctype.widen('+') == __olds[0])
+     {
+       __news[0] = __olds[0];
+       __mod = 1;
+       ++__news;
+     }
+   else if (__ctype.widen('0') == __olds[0]
+     && __oldlen > 1
+     && (__ctype.widen('x') == __olds[1]
+         || __ctype.widen('X') == __olds[1]))
+     {
+       __news[0] = __olds[0];
+       __news[1] = __olds[1];
+       __mod = 2;
+       __news += 2;
+     }
+
+ }
+      _Traits::assign(__news, __plen, __fill);
+      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
+    }
+
+  template<typename _CharT>
+    _CharT*
+    __add_grouping(_CharT* __s, _CharT __sep,
+     const char* __gbeg, size_t __gsize,
+     const _CharT* __first, const _CharT* __last)
+    {
+      size_t __idx = 0;
+      size_t __ctr = 0;
+
+      while (__last - __first > __gbeg[__idx]
+      && static_cast<signed char>(__gbeg[__idx]) > 0
+      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
+ {
+   __last -= __gbeg[__idx];
+   __idx < __gsize - 1 ? ++__idx : ++__ctr;
+ }
+
+      while (__first != __last)
+ *__s++ = *__first++;
+
+      while (__ctr--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      while (__idx--)
+ {
+   *__s++ = __sep;
+   for (char __i = __gbeg[__idx]; __i > 0; --__i)
+     *__s++ = *__first++;
+ }
+
+      return __s;
+    }
+
+
+
+
+
+  extern template class numpunct<char>;
+  extern template class numpunct_byname<char>;
+  extern template class num_get<char>;
+  extern template class num_put<char>;
+  extern template class ctype_byname<char>;
+
+  extern template
+    const ctype<char>&
+    use_facet<ctype<char> >(const locale&);
+
+  extern template
+    const numpunct<char>&
+    use_facet<numpunct<char> >(const locale&);
+
+  extern template
+    const num_put<char>&
+    use_facet<num_put<char> >(const locale&);
+
+  extern template
+    const num_get<char>&
+    use_facet<num_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<ctype<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<char> >(const locale&);
+
+
+  extern template class numpunct<wchar_t>;
+  extern template class numpunct_byname<wchar_t>;
+  extern template class num_get<wchar_t>;
+  extern template class num_put<wchar_t>;
+  extern template class ctype_byname<wchar_t>;
+
+  extern template
+    const ctype<wchar_t>&
+    use_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    const numpunct<wchar_t>&
+    use_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    const num_put<wchar_t>&
+    use_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    const num_get<wchar_t>&
+    use_facet<num_get<wchar_t> >(const locale&);
+
+ extern template
+    bool
+    has_facet<ctype<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<numpunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<num_get<wchar_t> >(const locale&);
+
+
+
+}
+# 2602 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets.h" 2 3
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Facet>
+    inline const _Facet&
+    __check_facet(const _Facet* __f)
+    {
+      if (!__f)
+ __throw_bad_cast();
+      return *__f;
+    }
+# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ios : public ios_base
+    {
+    public:
+
+
+
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+
+
+
+
+      typedef ctype<_CharT> __ctype_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+           __num_put_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+           __num_get_type;
+
+
+
+    public:
+      basic_ostream<_CharT, _Traits>* _M_tie;
+      mutable char_type _M_fill;
+      mutable bool _M_fill_init;
+      basic_streambuf<_CharT, _Traits>* _M_streambuf;
+
+
+      const __ctype_type* _M_ctype;
+
+      const __num_put_type* _M_num_put;
+
+      const __num_get_type* _M_num_get;
+
+    public:
+
+
+
+
+
+
+
+      operator void*() const
+      { return this->fail() ? 0 : const_cast<basic_ios*>(this); }
+
+      bool
+      operator!() const
+      { return this->fail(); }
+# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      iostate
+      rdstate() const
+      { return _M_streambuf_state; }
+# 137 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      void
+      clear(iostate __state = goodbit);
+
+
+
+
+
+
+
+      void
+      setstate(iostate __state)
+      { this->clear(this->rdstate() | __state); }
+
+
+
+
+      void
+      _M_setstate(iostate __state)
+      {
+
+
+ _M_streambuf_state |= __state;
+ if (this->exceptions() & __state)
+   throw;
+      }
+
+
+
+
+
+
+
+      bool
+      good() const
+      { return this->rdstate() == 0; }
+
+
+
+
+
+
+
+      bool
+      eof() const
+      { return (this->rdstate() & eofbit) != 0; }
+# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      bool
+      fail() const
+      { return (this->rdstate() & (badbit | failbit)) != 0; }
+
+
+
+
+
+
+
+      bool
+      bad() const
+      { return (this->rdstate() & badbit) != 0; }
+# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      iostate
+      exceptions() const
+      { return _M_exception; }
+# 246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      void
+      exceptions(iostate __except)
+      {
+        _M_exception = __except;
+        this->clear(_M_streambuf_state);
+      }
+
+
+
+
+
+
+
+      explicit
+      basic_ios(basic_streambuf<_CharT, _Traits>* __sb)
+      : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0),
+ _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { this->init(__sb); }
+
+
+
+
+
+
+
+      virtual
+      ~basic_ios() { }
+# 284 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie() const
+      { return _M_tie; }
+# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      basic_ostream<_CharT, _Traits>*
+      tie(basic_ostream<_CharT, _Traits>* __tiestr)
+      {
+        basic_ostream<_CharT, _Traits>* __old = _M_tie;
+        _M_tie = __tiestr;
+        return __old;
+      }
+
+
+
+
+
+
+
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf() const
+      { return _M_streambuf; }
+# 336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      basic_streambuf<_CharT, _Traits>*
+      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
+# 350 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      basic_ios&
+      copyfmt(const basic_ios& __rhs);
+
+
+
+
+
+
+
+      char_type
+      fill() const
+      {
+ if (!_M_fill_init)
+   {
+     _M_fill = this->widen(' ');
+     _M_fill_init = true;
+   }
+ return _M_fill;
+      }
+# 379 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      char_type
+      fill(char_type __ch)
+      {
+ char_type __old = this->fill();
+ _M_fill = __ch;
+ return __old;
+      }
+# 399 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      locale
+      imbue(const locale& __loc);
+# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      char
+      narrow(char_type __c, char __dfault) const
+      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
+# 438 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 3
+      char_type
+      widen(char __c) const
+      { return __check_facet(_M_ctype).widen(__c); }
+
+    public:
+
+
+
+
+
+
+
+      basic_ios()
+      : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false),
+ _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0)
+      { }
+
+
+
+
+
+
+
+      void
+      init(basic_streambuf<_CharT, _Traits>* __sb);
+
+      void
+      _M_cache_locale(const locale& __loc);
+    };
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 1 3
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 3
+       
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::clear(iostate __state)
+    {
+      if (this->rdbuf())
+ _M_streambuf_state = __state;
+      else
+   _M_streambuf_state = __state | badbit;
+      if (this->exceptions() & this->rdstate())
+ __throw_ios_failure(("basic_ios::clear"));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_streambuf<_CharT, _Traits>*
+    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
+      _M_streambuf = __sb;
+      this->clear();
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ios<_CharT, _Traits>&
+    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
+    {
+
+
+      if (this != &__rhs)
+ {
+
+
+
+
+   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
+                      _M_local_word : new _Words[__rhs._M_word_size];
+
+
+   _Callback_list* __cb = __rhs._M_callbacks;
+   if (__cb)
+     __cb->_M_add_reference();
+   _M_call_callbacks(erase_event);
+   if (_M_word != _M_local_word)
+     {
+       delete [] _M_word;
+       _M_word = 0;
+     }
+   _M_dispose_callbacks();
+
+
+   _M_callbacks = __cb;
+   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
+     __words[__i] = __rhs._M_word[__i];
+   _M_word = __words;
+   _M_word_size = __rhs._M_word_size;
+
+   this->flags(__rhs.flags());
+   this->width(__rhs.width());
+   this->precision(__rhs.precision());
+   this->tie(__rhs.tie());
+   this->fill(__rhs.fill());
+   _M_ios_locale = __rhs.getloc();
+   _M_cache_locale(_M_ios_locale);
+
+   _M_call_callbacks(copyfmt_event);
+
+
+   this->exceptions(__rhs.exceptions());
+ }
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    locale
+    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
+    {
+      locale __old(this->getloc());
+      ios_base::imbue(__loc);
+      _M_cache_locale(__loc);
+      if (this->rdbuf() != 0)
+ this->rdbuf()->pubimbue(__loc);
+      return __old;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
+    {
+
+      ios_base::_M_init();
+
+
+      _M_cache_locale(_M_ios_locale);
+# 145 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.tcc" 3
+      _M_fill = _CharT();
+      _M_fill_init = false;
+
+      _M_tie = 0;
+      _M_exception = goodbit;
+      _M_streambuf = __sb;
+      _M_streambuf_state = __sb ? goodbit : badbit;
+    }
+
+  template<typename _CharT, typename _Traits>
+    void
+    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
+    {
+      if (__builtin_expect(has_facet<__ctype_type>(__loc), true))
+ _M_ctype = &use_facet<__ctype_type>(__loc);
+      else
+ _M_ctype = 0;
+
+      if (__builtin_expect(has_facet<__num_put_type>(__loc), true))
+ _M_num_put = &use_facet<__num_put_type>(__loc);
+      else
+ _M_num_put = 0;
+
+      if (__builtin_expect(has_facet<__num_get_type>(__loc), true))
+ _M_num_get = &use_facet<__num_get_type>(__loc);
+      else
+ _M_num_get = 0;
+    }
+
+
+
+
+
+  extern template class basic_ios<char>;
+
+
+  extern template class basic_ios<wchar_t>;
+
+
+
+}
+# 472 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/basic_ios.h" 2 3
+# 46 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ios" 2 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
+             __num_put_type;
+      typedef ctype<_CharT> __ctype_type;
+# 81 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      explicit
+      basic_ostream(__streambuf_type* __sb)
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_ostream() { }
+
+
+      class sentry;
+      friend class sentry;
+# 107 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      __ostream_type&
+      operator<<(__ostream_type& (*__pf)(__ostream_type&))
+      {
+
+
+
+ return __pf(*this);
+      }
+
+      __ostream_type&
+      operator<<(__ios_type& (*__pf)(__ios_type&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+
+      __ostream_type&
+      operator<<(ios_base& (*__pf) (ios_base&))
+      {
+
+
+
+ __pf(*this);
+ return *this;
+      }
+# 164 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      __ostream_type&
+      operator<<(long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(bool __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(short __n);
+
+      __ostream_type&
+      operator<<(unsigned short __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+      __ostream_type&
+      operator<<(int __n);
+
+      __ostream_type&
+      operator<<(unsigned int __n)
+      {
+
+
+ return _M_insert(static_cast<unsigned long>(__n));
+      }
+
+
+      __ostream_type&
+      operator<<(long long __n)
+      { return _M_insert(__n); }
+
+      __ostream_type&
+      operator<<(unsigned long long __n)
+      { return _M_insert(__n); }
+
+
+      __ostream_type&
+      operator<<(double __f)
+      { return _M_insert(__f); }
+
+      __ostream_type&
+      operator<<(float __f)
+      {
+
+
+ return _M_insert(static_cast<double>(__f));
+      }
+
+      __ostream_type&
+      operator<<(long double __f)
+      { return _M_insert(__f); }
+
+      __ostream_type&
+      operator<<(const void* __p)
+      { return _M_insert(__p); }
+# 249 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      __ostream_type&
+      operator<<(__streambuf_type* __sb);
+# 282 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      __ostream_type&
+      put(char_type __c);
+
+
+      void
+      _M_write(const char_type* __s, streamsize __n)
+      {
+ const streamsize __put = this->rdbuf()->sputn(__s, __n);
+ if (__put != __n)
+   this->setstate(ios_base::badbit);
+      }
+# 310 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      __ostream_type&
+      write(const char_type* __s, streamsize __n);
+# 323 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      __ostream_type&
+      flush();
+# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      pos_type
+      tellp();
+# 345 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      __ostream_type&
+      seekp(pos_type);
+# 357 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+       __ostream_type&
+      seekp(off_type, ios_base::seekdir);
+
+    public:
+      basic_ostream()
+      { this->init(0); }
+
+      template<typename _ValueT>
+        __ostream_type&
+        _M_insert(_ValueT __v);
+    };
+# 376 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+  template <typename _CharT, typename _Traits>
+    class basic_ostream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+      basic_ostream<_CharT, _Traits>& _M_os;
+
+    public:
+# 395 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      explicit
+      sentry(basic_ostream<_CharT, _Traits>& __os);
+# 405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      ~sentry()
+      {
+
+ if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception())
+   {
+
+     if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1)
+       _M_os.setstate(ios_base::badbit);
+   }
+      }
+# 426 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+      operator bool() const
+      { return _M_ok; }
+    };
+# 447 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
+    { return (__out << __out.widen(__c)); }
+
+
+  template <class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, char __c)
+    { return __ostream_insert(__out, &__c, 1); }
+
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
+    { return (__out << static_cast<char>(__c)); }
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
+    { return (__out << static_cast<char>(__c)); }
+# 489 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits> &
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ __ostream_insert(__out, __s,
+    static_cast<streamsize>(_Traits::length(__s)));
+      return __out;
+    }
+
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits>&
+    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_ostream<char, _Traits> &
+    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
+    { return (__out << reinterpret_cast<const char*>(__s)); }
+# 539 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    endl(basic_ostream<_CharT, _Traits>& __os)
+    { return flush(__os.put(__os.widen('\n'))); }
+
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    ends(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.put(_CharT()); }
+
+
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    flush(basic_ostream<_CharT, _Traits>& __os)
+    { return __os.flush(); }
+# 583 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 3
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream.tcc" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream.tcc" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/ostream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>::sentry::
+    sentry(basic_ostream<_CharT, _Traits>& __os)
+    : _M_ok(false), _M_os(__os)
+    {
+
+      if (__os.tie() && __os.good())
+ __os.tie()->flush();
+
+      if (__os.good())
+ _M_ok = true;
+      else
+ __os.setstate(ios_base::failbit);
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_ostream<_CharT, _Traits>&
+      basic_ostream<_CharT, _Traits>::
+      _M_insert(_ValueT __v)
+      {
+ sentry __cerb(*this);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_put_type& __np = __check_facet(this->_M_num_put);
+  if (__np.put(*this, *this, this->fill(), __v).failed())
+    __err |= ios_base::badbit;
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(short __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(int __n)
+    {
+
+
+      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
+      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
+ return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
+      else
+ return _M_insert(static_cast<long>(__n));
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    operator<<(__streambuf_type* __sbin)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this);
+      if (__cerb && __sbin)
+ {
+   try
+     {
+       if (!__copy_streambufs(__sbin, this->rdbuf()))
+  __err |= ios_base::failbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbin)
+ __err |= ios_base::badbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    put(char_type __c)
+    {
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __put = this->rdbuf()->sputc(__c);
+       if (traits_type::eq_int_type(__put, traits_type::eof()))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    write(const _CharT* __s, streamsize __n)
+    {
+
+
+
+
+
+
+
+      sentry __cerb(*this);
+      if (__cerb)
+ {
+   try
+     { _M_write(__s, __n); }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    flush()
+    {
+
+
+
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (this->rdbuf() && this->rdbuf()->pubsync() == -1)
+     __err |= ios_base::badbit;
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_ostream<_CharT, _Traits>::pos_type
+    basic_ostream<_CharT, _Traits>::
+    tellp()
+    {
+      pos_type __ret = pos_type(-1);
+      try
+ {
+   if (!this->fail())
+     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(pos_type __pos)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    basic_ostream<_CharT, _Traits>::
+    seekp(off_type __off, ios_base::seekdir __dir)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+
+       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+            ios_base::out);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+    {
+      if (!__s)
+ __out.setstate(ios_base::badbit);
+      else
+ {
+
+
+   const size_t __clen = char_traits<char>::length(__s);
+   try
+     {
+       struct __ptr_guard
+       {
+  _CharT *__p;
+  __ptr_guard (_CharT *__ip): __p(__ip) { }
+  ~__ptr_guard() { delete[] __p; }
+  _CharT* __get() { return __p; }
+       } __pg (new _CharT[__clen]);
+
+       _CharT *__ws = __pg.__get();
+       for (size_t __i = 0; __i < __clen; ++__i)
+  __ws[__i] = __out.widen(__s[__i]);
+       __ostream_insert(__out, __ws, __clen);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __out._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __out._M_setstate(ios_base::badbit); }
+ }
+      return __out;
+    }
+
+
+
+
+
+  extern template class basic_ostream<char>;
+  extern template ostream& endl(ostream&);
+  extern template ostream& ends(ostream&);
+  extern template ostream& flush(ostream&);
+  extern template ostream& operator<<(ostream&, char);
+  extern template ostream& operator<<(ostream&, unsigned char);
+  extern template ostream& operator<<(ostream&, signed char);
+  extern template ostream& operator<<(ostream&, const char*);
+  extern template ostream& operator<<(ostream&, const unsigned char*);
+  extern template ostream& operator<<(ostream&, const signed char*);
+
+  extern template ostream& ostream::_M_insert(long);
+  extern template ostream& ostream::_M_insert(unsigned long);
+  extern template ostream& ostream::_M_insert(bool);
+
+  extern template ostream& ostream::_M_insert(long long);
+  extern template ostream& ostream::_M_insert(unsigned long long);
+
+  extern template ostream& ostream::_M_insert(double);
+  extern template ostream& ostream::_M_insert(long double);
+  extern template ostream& ostream::_M_insert(const void*);
+
+
+  extern template class basic_ostream<wchar_t>;
+  extern template wostream& endl(wostream&);
+  extern template wostream& ends(wostream&);
+  extern template wostream& flush(wostream&);
+  extern template wostream& operator<<(wostream&, wchar_t);
+  extern template wostream& operator<<(wostream&, char);
+  extern template wostream& operator<<(wostream&, const wchar_t*);
+  extern template wostream& operator<<(wostream&, const char*);
+
+  extern template wostream& wostream::_M_insert(long);
+  extern template wostream& wostream::_M_insert(unsigned long);
+  extern template wostream& wostream::_M_insert(bool);
+
+  extern template wostream& wostream::_M_insert(long long);
+  extern template wostream& wostream::_M_insert(unsigned long long);
+
+  extern template wostream& wostream::_M_insert(double);
+  extern template wostream& wostream::_M_insert(long double);
+  extern template wostream& wostream::_M_insert(const void*);
+
+
+
+}
+# 587 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ostream" 2 3
+# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+       
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 54 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream : virtual public basic_ios<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_ios<_CharT, _Traits> __ios_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
+        __num_get_type;
+      typedef ctype<_CharT> __ctype_type;
+
+    public:
+
+
+
+
+
+      streamsize _M_gcount;
+
+    public:
+# 90 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      explicit
+      basic_istream(__streambuf_type* __sb)
+      : _M_gcount(streamsize(0))
+      { this->init(__sb); }
+
+
+
+
+
+
+      virtual
+      ~basic_istream()
+      { _M_gcount = streamsize(0); }
+
+
+      class sentry;
+      friend class sentry;
+# 119 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      operator>>(__istream_type& (*__pf)(__istream_type&))
+      { return __pf(*this); }
+
+      __istream_type&
+      operator>>(__ios_type& (*__pf)(__ios_type&))
+      {
+ __pf(*this);
+ return *this;
+      }
+
+      __istream_type&
+      operator>>(ios_base& (*__pf)(ios_base&))
+      {
+ __pf(*this);
+ return *this;
+      }
+# 166 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      operator>>(bool& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(short& __n);
+
+      __istream_type&
+      operator>>(unsigned short& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(int& __n);
+
+      __istream_type&
+      operator>>(unsigned int& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long& __n)
+      { return _M_extract(__n); }
+
+
+      __istream_type&
+      operator>>(long long& __n)
+      { return _M_extract(__n); }
+
+      __istream_type&
+      operator>>(unsigned long long& __n)
+      { return _M_extract(__n); }
+
+
+      __istream_type&
+      operator>>(float& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(double& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(long double& __f)
+      { return _M_extract(__f); }
+
+      __istream_type&
+      operator>>(void*& __p)
+      { return _M_extract(__p); }
+# 238 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      operator>>(__streambuf_type* __sb);
+# 248 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      streamsize
+      gcount() const
+      { return _M_gcount; }
+# 280 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      int_type
+      get();
+# 294 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      get(char_type& __c);
+# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n, char_type __delim);
+# 332 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      get(char_type* __s, streamsize __n)
+      { return this->get(__s, __n, this->widen('\n')); }
+# 355 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb, char_type __delim);
+# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      get(__streambuf_type& __sb)
+      { return this->get(__sb, this->widen('\n')); }
+# 394 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n, char_type __delim);
+# 405 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      getline(char_type* __s, streamsize __n)
+      { return this->getline(__s, __n, this->widen('\n')); }
+# 429 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      ignore();
+
+      __istream_type&
+      ignore(streamsize __n);
+
+      __istream_type&
+      ignore(streamsize __n, int_type __delim);
+# 446 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      int_type
+      peek();
+# 464 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      read(char_type* __s, streamsize __n);
+# 483 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      streamsize
+      readsome(char_type* __s, streamsize __n);
+# 499 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      putback(char_type __c);
+# 514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      unget();
+# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      int
+      sync();
+# 546 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      pos_type
+      tellg();
+# 561 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      seekg(pos_type);
+# 577 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      __istream_type&
+      seekg(off_type, ios_base::seekdir);
+
+
+    public:
+      basic_istream()
+      : _M_gcount(streamsize(0))
+      { this->init(0); }
+
+      template<typename _ValueT>
+        __istream_type&
+        _M_extract(_ValueT& __v);
+    };
+
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<char>&
+    basic_istream<char>::
+    ignore(streamsize __n, int_type __delim);
+
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    getline(char_type* __s, streamsize __n, char_type __delim);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n);
+
+  template<>
+    basic_istream<wchar_t>&
+    basic_istream<wchar_t>::
+    ignore(streamsize __n, int_type __delim);
+# 632 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_istream<_CharT, _Traits>::sentry
+    {
+
+      bool _M_ok;
+
+    public:
+
+      typedef _Traits traits_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::__ctype_type __ctype_type;
+      typedef typename _Traits::int_type __int_type;
+# 668 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      explicit
+      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
+# 681 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+      operator bool() const
+      { return _M_ok; }
+    };
+# 698 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
+    { return (__in >> reinterpret_cast<char&>(__c)); }
+# 740 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s);
+
+
+  template<>
+    basic_istream<char>&
+    operator>>(basic_istream<char>& __in, char* __s);
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+
+  template<class _Traits>
+    inline basic_istream<char, _Traits>&
+    operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
+    { return (__in >> reinterpret_cast<char*>(__s)); }
+# 768 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+  template<typename _CharT, typename _Traits>
+    class basic_iostream
+    : public basic_istream<_CharT, _Traits>,
+      public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef typename _Traits::int_type int_type;
+      typedef typename _Traits::pos_type pos_type;
+      typedef typename _Traits::off_type off_type;
+      typedef _Traits traits_type;
+
+
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_ostream<_CharT, _Traits> __ostream_type;
+
+
+
+
+
+
+
+      explicit
+      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
+      : __istream_type(__sb), __ostream_type(__sb) { }
+
+
+
+
+      virtual
+      ~basic_iostream() { }
+
+    public:
+      basic_iostream()
+      : __istream_type(), __ostream_type() { }
+    };
+# 829 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __is);
+# 851 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 3
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>::sentry::
+    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      if (__in.good())
+ {
+   if (__in.tie())
+     __in.tie()->flush();
+   if (!__noskip && bool(__in.flags() & ios_base::skipws))
+     {
+       const __int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       __int_type __c = __sb->sgetc();
+
+       const __ctype_type& __ct = __check_facet(__in._M_ctype);
+       while (!traits_type::eq_int_type(__c, __eof)
+       && __ct.is(ctype_base::space,
+    traits_type::to_char_type(__c)))
+  __c = __sb->snextc();
+
+
+
+
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+ }
+
+      if (__in.good() && __err == ios_base::goodbit)
+ _M_ok = true;
+      else
+ {
+   __err |= ios_base::failbit;
+   __in.setstate(__err);
+ }
+    }
+
+  template<typename _CharT, typename _Traits>
+    template<typename _ValueT>
+      basic_istream<_CharT, _Traits>&
+      basic_istream<_CharT, _Traits>::
+      _M_extract(_ValueT& __v)
+      {
+ sentry __cerb(*this, false);
+ if (__cerb)
+   {
+     ios_base::iostate __err = ios_base::goodbit;
+     try
+       {
+  const __num_get_type& __ng = __check_facet(this->_M_num_get);
+  __ng.get(*this, 0, *this, __err, __v);
+       }
+     catch(__cxxabiv1::__forced_unwind&)
+       {
+  this->_M_setstate(ios_base::badbit);
+  throw;
+       }
+     catch(...)
+       { this->_M_setstate(ios_base::badbit); }
+     if (__err)
+       this->setstate(__err);
+   }
+ return *this;
+      }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(short& __n)
+    {
+
+
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+
+
+
+       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<short>::__max;
+  }
+       else
+  __n = short(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(int& __n)
+    {
+
+
+      sentry __cerb(*this, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       long __l;
+       const __num_get_type& __ng = __check_facet(this->_M_num_get);
+       __ng.get(*this, 0, *this, __err, __l);
+
+
+
+       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__min;
+  }
+       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
+  {
+    __err |= ios_base::failbit;
+    __n = __gnu_cxx::__numeric_traits<int>::__max;
+  }
+       else
+  __n = int(__l);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    operator>>(__streambuf_type* __sbout)
+    {
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, false);
+      if (__cerb && __sbout)
+ {
+   try
+     {
+       bool __ineof;
+       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
+  __err |= ios_base::failbit;
+       if (__ineof)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::failbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::failbit); }
+ }
+      else if (!__sbout)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    get(void)
+    {
+      const int_type __eof = traits_type::eof();
+      int_type __c = __eof;
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       __c = this->rdbuf()->sbumpc();
+
+       if (!traits_type::eq_int_type(__c, __eof))
+  _M_gcount = 1;
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type& __c)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __cb = this->rdbuf()->sbumpc();
+
+       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
+  {
+    _M_gcount = 1;
+    __c = traits_type::to_char_type(__cb);
+  }
+       else
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       int_type __c = __sb->sgetc();
+
+       while (_M_gcount + 1 < __n
+       && !traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim))
+  {
+    *__s++ = traits_type::to_char_type(__c);
+    ++_M_gcount;
+    __c = __sb->snextc();
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+
+
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    get(__streambuf_type& __sb, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   try
+     {
+       const int_type __idelim = traits_type::to_int_type(__delim);
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __this_sb = this->rdbuf();
+       int_type __c = __this_sb->sgetc();
+       char_type __c2 = traits_type::to_char_type(__c);
+
+       while (!traits_type::eq_int_type(__c, __eof)
+       && !traits_type::eq_int_type(__c, __idelim)
+       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
+  {
+    ++_M_gcount;
+    __c = __this_sb->snextc();
+    __c2 = traits_type::to_char_type(__c);
+  }
+       if (traits_type::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+ }
+      if (!_M_gcount)
+ __err |= ios_base::failbit;
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    getline(char_type* __s, streamsize __n, char_type __delim)
+    {
+      _M_gcount = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      sentry __cerb(*this, true);
+      if (__cerb)
+        {
+          try
+            {
+              const int_type __idelim = traits_type::to_int_type(__delim);
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+              while (_M_gcount + 1 < __n
+                     && !traits_type::eq_int_type(__c, __eof)
+                     && !traits_type::eq_int_type(__c, __idelim))
+                {
+                  *__s++ = traits_type::to_char_type(__c);
+                  __c = __sb->snextc();
+                  ++_M_gcount;
+                }
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+              else
+                {
+                  if (traits_type::eq_int_type(__c, __idelim))
+                    {
+                      __sb->sbumpc();
+                      ++_M_gcount;
+                    }
+                  else
+                    __err |= ios_base::failbit;
+                }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+        }
+
+
+      if (__n > 0)
+ *__s = char_type();
+      if (!_M_gcount)
+        __err |= ios_base::failbit;
+      if (__err)
+        this->setstate(__err);
+      return *this;
+    }
+
+
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(void)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+
+       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
+  __err |= ios_base::eofbit;
+       else
+  _M_gcount = 1;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+# 513 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/istream.tcc" 3
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    ignore(streamsize __n, int_type __delim)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb && __n > 0)
+        {
+          ios_base::iostate __err = ios_base::goodbit;
+          try
+            {
+              const int_type __eof = traits_type::eof();
+              __streambuf_type* __sb = this->rdbuf();
+              int_type __c = __sb->sgetc();
+
+
+       bool __large_ignore = false;
+       while (true)
+  {
+    while (_M_gcount < __n
+    && !traits_type::eq_int_type(__c, __eof)
+    && !traits_type::eq_int_type(__c, __delim))
+      {
+        ++_M_gcount;
+        __c = __sb->snextc();
+      }
+    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
+        && !traits_type::eq_int_type(__c, __eof)
+        && !traits_type::eq_int_type(__c, __delim))
+      {
+        _M_gcount =
+   __gnu_cxx::__numeric_traits<streamsize>::__min;
+        __large_ignore = true;
+      }
+    else
+      break;
+  }
+
+       if (__large_ignore)
+  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+              if (traits_type::eq_int_type(__c, __eof))
+                __err |= ios_base::eofbit;
+       else if (traits_type::eq_int_type(__c, __delim))
+  {
+    if (_M_gcount
+        < __gnu_cxx::__numeric_traits<streamsize>::__max)
+      ++_M_gcount;
+    __sb->sbumpc();
+  }
+            }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+          catch(...)
+            { this->_M_setstate(ios_base::badbit); }
+          if (__err)
+            this->setstate(__err);
+        }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::int_type
+    basic_istream<_CharT, _Traits>::
+    peek(void)
+    {
+      int_type __c = traits_type::eof();
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __c = this->rdbuf()->sgetc();
+       if (traits_type::eq_int_type(__c, traits_type::eof()))
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __c;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    read(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       _M_gcount = this->rdbuf()->sgetn(__s, __n);
+       if (_M_gcount != __n)
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    streamsize
+    basic_istream<_CharT, _Traits>::
+    readsome(char_type* __s, streamsize __n)
+    {
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+
+       const streamsize __num = this->rdbuf()->in_avail();
+       if (__num > 0)
+  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
+       else if (__num == -1)
+  __err |= ios_base::eofbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return _M_gcount;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    putback(char_type __c)
+    {
+
+
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    unget(void)
+    {
+
+
+      _M_gcount = 0;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const int_type __eof = traits_type::eof();
+       __streambuf_type* __sb = this->rdbuf();
+       if (!__sb
+    || traits_type::eq_int_type(__sb->sungetc(), __eof))
+  __err |= ios_base::badbit;
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    int
+    basic_istream<_CharT, _Traits>::
+    sync(void)
+    {
+
+
+      int __ret = -1;
+      sentry __cerb(*this, true);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       __streambuf_type* __sb = this->rdbuf();
+       if (__sb)
+  {
+    if (__sb->pubsync() == -1)
+      __err |= ios_base::badbit;
+    else
+      __ret = 0;
+  }
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       this->_M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { this->_M_setstate(ios_base::badbit); }
+   if (__err)
+     this->setstate(__err);
+ }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    typename basic_istream<_CharT, _Traits>::pos_type
+    basic_istream<_CharT, _Traits>::
+    tellg(void)
+    {
+
+
+      pos_type __ret = pos_type(-1);
+      try
+ {
+   if (!this->fail())
+     __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
+           ios_base::in);
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      return __ret;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(pos_type __pos)
+    {
+
+
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+       const pos_type __p = this->rdbuf()->pubseekpos(__pos,
+            ios_base::in);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    basic_istream<_CharT, _Traits>::
+    seekg(off_type __off, ios_base::seekdir __dir)
+    {
+
+
+      ios_base::iostate __err = ios_base::goodbit;
+      try
+ {
+   if (!this->fail())
+     {
+
+       const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
+            ios_base::in);
+
+
+       if (__p == pos_type(off_type(-1)))
+  __err |= ios_base::failbit;
+     }
+ }
+      catch(__cxxabiv1::__forced_unwind&)
+ {
+   this->_M_setstate(ios_base::badbit);
+   throw;
+ }
+      catch(...)
+ { this->_M_setstate(ios_base::badbit); }
+      if (__err)
+ this->setstate(__err);
+      return *this;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef typename __istream_type::int_type __int_type;
+
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   ios_base::iostate __err = ios_base::goodbit;
+   try
+     {
+       const __int_type __cb = __in.rdbuf()->sbumpc();
+       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
+  __c = _Traits::to_char_type(__cb);
+       else
+  __err |= (ios_base::eofbit | ios_base::failbit);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+   if (__err)
+     __in.setstate(__err);
+ }
+      return __in;
+    }
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename _Traits::int_type int_type;
+      typedef _CharT char_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      streamsize __extracted = 0;
+      ios_base::iostate __err = ios_base::goodbit;
+      typename __istream_type::sentry __cerb(__in, false);
+      if (__cerb)
+ {
+   try
+     {
+
+       streamsize __num = __in.width();
+       if (__num <= 0)
+  __num = __gnu_cxx::__numeric_traits<streamsize>::__max;
+
+       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+
+       const int_type __eof = _Traits::eof();
+       __streambuf_type* __sb = __in.rdbuf();
+       int_type __c = __sb->sgetc();
+
+       while (__extracted < __num - 1
+       && !_Traits::eq_int_type(__c, __eof)
+       && !__ct.is(ctype_base::space,
+     _Traits::to_char_type(__c)))
+  {
+    *__s++ = _Traits::to_char_type(__c);
+    ++__extracted;
+    __c = __sb->snextc();
+  }
+       if (_Traits::eq_int_type(__c, __eof))
+  __err |= ios_base::eofbit;
+
+
+
+       *__s = char_type();
+       __in.width(0);
+     }
+   catch(__cxxabiv1::__forced_unwind&)
+     {
+       __in._M_setstate(ios_base::badbit);
+       throw;
+     }
+   catch(...)
+     { __in._M_setstate(ios_base::badbit); }
+ }
+      if (!__extracted)
+ __err |= ios_base::failbit;
+      if (__err)
+ __in.setstate(__err);
+      return __in;
+    }
+
+
+  template<typename _CharT, typename _Traits>
+    basic_istream<_CharT, _Traits>&
+    ws(basic_istream<_CharT, _Traits>& __in)
+    {
+      typedef basic_istream<_CharT, _Traits> __istream_type;
+      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
+      typedef typename __istream_type::int_type __int_type;
+      typedef ctype<_CharT> __ctype_type;
+
+      const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+      const __int_type __eof = _Traits::eof();
+      __streambuf_type* __sb = __in.rdbuf();
+      __int_type __c = __sb->sgetc();
+
+      while (!_Traits::eq_int_type(__c, __eof)
+      && __ct.is(ctype_base::space, _Traits::to_char_type(__c)))
+ __c = __sb->snextc();
+
+       if (_Traits::eq_int_type(__c, __eof))
+  __in.setstate(ios_base::eofbit);
+      return __in;
+    }
+
+
+
+
+
+  extern template class basic_istream<char>;
+  extern template istream& ws(istream&);
+  extern template istream& operator>>(istream&, char&);
+  extern template istream& operator>>(istream&, char*);
+  extern template istream& operator>>(istream&, unsigned char&);
+  extern template istream& operator>>(istream&, signed char&);
+  extern template istream& operator>>(istream&, unsigned char*);
+  extern template istream& operator>>(istream&, signed char*);
+
+  extern template istream& istream::_M_extract(unsigned short&);
+  extern template istream& istream::_M_extract(unsigned int&);
+  extern template istream& istream::_M_extract(long&);
+  extern template istream& istream::_M_extract(unsigned long&);
+  extern template istream& istream::_M_extract(bool&);
+
+  extern template istream& istream::_M_extract(long long&);
+  extern template istream& istream::_M_extract(unsigned long long&);
+
+  extern template istream& istream::_M_extract(float&);
+  extern template istream& istream::_M_extract(double&);
+  extern template istream& istream::_M_extract(long double&);
+  extern template istream& istream::_M_extract(void*&);
+
+  extern template class basic_iostream<char>;
+
+
+  extern template class basic_istream<wchar_t>;
+  extern template wistream& ws(wistream&);
+  extern template wistream& operator>>(wistream&, wchar_t&);
+  extern template wistream& operator>>(wistream&, wchar_t*);
+
+  extern template wistream& wistream::_M_extract(unsigned short&);
+  extern template wistream& wistream::_M_extract(unsigned int&);
+  extern template wistream& wistream::_M_extract(long&);
+  extern template wistream& wistream::_M_extract(unsigned long&);
+  extern template wistream& wistream::_M_extract(bool&);
+
+  extern template wistream& wistream::_M_extract(long long&);
+  extern template wistream& wistream::_M_extract(unsigned long long&);
+
+  extern template wistream& wistream::_M_extract(float&);
+  extern template wistream& wistream::_M_extract(double&);
+  extern template wistream& wistream::_M_extract(long double&);
+  extern template wistream& wistream::_M_extract(void*&);
+
+  extern template class basic_iostream<wchar_t>;
+
+
+
+}
+# 855 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/istream" 2 3
+# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3
+       
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+
+
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
+    class istream_iterator
+    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_istream<_CharT, _Traits> istream_type;
+
+    private:
+      istream_type* _M_stream;
+      _Tp _M_value;
+      bool _M_ok;
+
+    public:
+
+      istream_iterator()
+      : _M_stream(0), _M_value(), _M_ok(false) {}
+
+
+      istream_iterator(istream_type& __s)
+      : _M_stream(&__s)
+      { _M_read(); }
+
+      istream_iterator(const istream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_value(__obj._M_value),
+        _M_ok(__obj._M_ok)
+      { }
+
+      const _Tp&
+      operator*() const
+      {
+
+
+                        ;
+ return _M_value;
+      }
+
+      const _Tp*
+      operator->() const { return &(operator*()); }
+
+      istream_iterator&
+      operator++()
+      {
+
+
+                        ;
+ _M_read();
+ return *this;
+      }
+
+      istream_iterator
+      operator++(int)
+      {
+
+
+                        ;
+ istream_iterator __tmp = *this;
+ _M_read();
+ return __tmp;
+      }
+
+      bool
+      _M_equal(const istream_iterator& __x) const
+      { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); }
+
+    private:
+      void
+      _M_read()
+      {
+ _M_ok = (_M_stream && *_M_stream) ? true : false;
+ if (_M_ok)
+   {
+     *_M_stream >> _M_value;
+     _M_ok = *_M_stream ? true : false;
+   }
+      }
+    };
+
+
+  template<typename _Tp, typename _CharT, typename _Traits, typename _Dist>
+    inline bool
+    operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return __x._M_equal(__y); }
+
+
+  template <class _Tp, class _CharT, class _Traits, class _Dist>
+    inline bool
+    operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x,
+        const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y)
+    { return !__x._M_equal(__y); }
+# 150 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3
+  template<typename _Tp, typename _CharT = char,
+           typename _Traits = char_traits<_CharT> >
+    class ostream_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+      typedef basic_ostream<_CharT, _Traits> ostream_type;
+
+
+    private:
+      ostream_type* _M_stream;
+      const _CharT* _M_string;
+
+    public:
+
+      ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {}
+# 181 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stream_iterator.h" 3
+      ostream_iterator(ostream_type& __s, const _CharT* __c)
+      : _M_stream(&__s), _M_string(__c) { }
+
+
+      ostream_iterator(const ostream_iterator& __obj)
+      : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { }
+
+
+
+      ostream_iterator&
+      operator=(const _Tp& __value)
+      {
+
+
+                        ;
+ *_M_stream << __value;
+ if (_M_string) *_M_stream << _M_string;
+ return *this;
+      }
+
+      ostream_iterator&
+      operator*()
+      { return *this; }
+
+      ostream_iterator&
+      operator++()
+      { return *this; }
+
+      ostream_iterator&
+      operator++(int)
+      { return *this; }
+    };
+
+
+
+}
+# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iterator" 2 3
+# 51 "/usr/include/qt4/QtCore/qlist.h" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 1 3
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 3
+       
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+
+
+  struct _List_node_base
+  {
+    _List_node_base* _M_next;
+    _List_node_base* _M_prev;
+
+    static void
+    swap(_List_node_base& __x, _List_node_base& __y) throw ();
+
+    void
+    _M_transfer(_List_node_base * const __first,
+  _List_node_base * const __last) throw ();
+
+    void
+    _M_reverse() throw ();
+
+    void
+    _M_hook(_List_node_base * const __position) throw ();
+
+    void
+    _M_unhook() throw ();
+  };
+
+
+  template<typename _Tp>
+    struct _List_node : public _List_node_base
+    {
+
+      _Tp _M_data;
+
+
+
+
+
+
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _List_iterator
+    {
+      typedef _List_iterator<_Tp> _Self;
+      typedef _List_node<_Tp> _Node;
+
+      typedef ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef _Tp* pointer;
+      typedef _Tp& reference;
+
+      _List_iterator()
+      : _M_node() { }
+
+      explicit
+      _List_iterator(_List_node_base* __x)
+      : _M_node(__x) { }
+
+
+      reference
+      operator*() const
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+
+      pointer
+      operator->() const
+      { return &static_cast<_Node*>(_M_node)->_M_data; }
+
+      _Self&
+      operator++()
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+
+      _Self&
+      operator--()
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+
+
+      _List_node_base* _M_node;
+    };
+
+
+
+
+
+
+  template<typename _Tp>
+    struct _List_const_iterator
+    {
+      typedef _List_const_iterator<_Tp> _Self;
+      typedef const _List_node<_Tp> _Node;
+      typedef _List_iterator<_Tp> iterator;
+
+      typedef ptrdiff_t difference_type;
+      typedef std::bidirectional_iterator_tag iterator_category;
+      typedef _Tp value_type;
+      typedef const _Tp* pointer;
+      typedef const _Tp& reference;
+
+      _List_const_iterator()
+      : _M_node() { }
+
+      explicit
+      _List_const_iterator(const _List_node_base* __x)
+      : _M_node(__x) { }
+
+      _List_const_iterator(const iterator& __x)
+      : _M_node(__x._M_node) { }
+
+
+
+      reference
+      operator*() const
+      { return static_cast<_Node*>(_M_node)->_M_data; }
+
+      pointer
+      operator->() const
+      { return &static_cast<_Node*>(_M_node)->_M_data; }
+
+      _Self&
+      operator++()
+      {
+ _M_node = _M_node->_M_next;
+ return *this;
+      }
+
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_next;
+ return __tmp;
+      }
+
+      _Self&
+      operator--()
+      {
+ _M_node = _M_node->_M_prev;
+ return *this;
+      }
+
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _M_node->_M_prev;
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+
+
+      const _List_node_base* _M_node;
+    };
+
+  template<typename _Val>
+    inline bool
+    operator==(const _List_iterator<_Val>& __x,
+        const _List_const_iterator<_Val>& __y)
+    { return __x._M_node == __y._M_node; }
+
+  template<typename _Val>
+    inline bool
+    operator!=(const _List_iterator<_Val>& __x,
+               const _List_const_iterator<_Val>& __y)
+    { return __x._M_node != __y._M_node; }
+
+
+
+  template<typename _Tp, typename _Alloc>
+    class _List_base
+    {
+    public:
+# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      typedef typename _Alloc::template rebind<_List_node<_Tp> >::other
+        _Node_alloc_type;
+
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+
+      struct _List_impl
+      : public _Node_alloc_type
+      {
+ _List_node_base _M_node;
+
+ _List_impl()
+ : _Node_alloc_type(), _M_node()
+ { }
+
+ _List_impl(const _Node_alloc_type& __a)
+ : _Node_alloc_type(__a), _M_node()
+ { }
+      };
+
+      _List_impl _M_impl;
+
+      _List_node<_Tp>*
+      _M_get_node()
+      { return _M_impl._Node_alloc_type::allocate(1); }
+
+      void
+      _M_put_node(_List_node<_Tp>* __p)
+      { _M_impl._Node_alloc_type::deallocate(__p, 1); }
+
+  public:
+      typedef _Alloc allocator_type;
+
+      _Node_alloc_type&
+      _M_get_Node_allocator()
+      { return *static_cast<_Node_alloc_type*>(&this->_M_impl); }
+
+      const _Node_alloc_type&
+      _M_get_Node_allocator() const
+      { return *static_cast<const _Node_alloc_type*>(&this->_M_impl); }
+
+      _Tp_alloc_type
+      _M_get_Tp_allocator() const
+      { return _Tp_alloc_type(_M_get_Node_allocator()); }
+
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Node_allocator()); }
+
+      _List_base()
+      : _M_impl()
+      { _M_init(); }
+
+      _List_base(const allocator_type& __a)
+      : _M_impl(__a)
+      { _M_init(); }
+# 359 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      ~_List_base()
+      { _M_clear(); }
+
+      void
+      _M_clear();
+
+      void
+      _M_init()
+      {
+        this->_M_impl._M_node._M_next = &this->_M_impl._M_node;
+        this->_M_impl._M_node._M_prev = &this->_M_impl._M_node;
+      }
+    };
+# 416 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class list : public _List_base<_Tp, _Alloc>
+    {
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+     
+     
+
+      typedef _List_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+
+    public:
+      typedef _Tp value_type;
+      typedef typename _Tp_alloc_type::pointer pointer;
+      typedef typename _Tp_alloc_type::const_pointer const_pointer;
+      typedef typename _Tp_alloc_type::reference reference;
+      typedef typename _Tp_alloc_type::const_reference const_reference;
+      typedef _List_iterator<_Tp> iterator;
+      typedef _List_const_iterator<_Tp> const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+    public:
+
+
+      typedef _List_node<_Tp> _Node;
+
+      using _Base::_M_impl;
+      using _Base::_M_put_node;
+      using _Base::_M_get_node;
+      using _Base::_M_get_Tp_allocator;
+      using _Base::_M_get_Node_allocator;
+
+
+
+
+
+
+
+      _Node*
+      _M_create_node(const value_type& __x)
+      {
+ _Node* __p = this->_M_get_node();
+ try
+   {
+     _M_get_Tp_allocator().construct(&__p->_M_data, __x);
+   }
+ catch(...)
+   {
+     _M_put_node(__p);
+     throw;
+   }
+ return __p;
+      }
+# 493 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+    public:
+
+
+
+
+
+      list()
+      : _Base() { }
+
+
+
+
+
+      explicit
+      list(const allocator_type& __a)
+      : _Base(__a) { }
+# 518 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      explicit
+      list(size_type __n, const value_type& __value = value_type(),
+    const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      { _M_fill_initialize(__n, __value); }
+# 531 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      list(const list& __x)
+      : _Base(__x._M_get_Node_allocator())
+      { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); }
+# 570 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      template<typename _InputIterator>
+        list(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+        : _Base(__a)
+        {
+
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_initialize_dispatch(__first, __last, _Integral());
+ }
+# 595 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      list&
+      operator=(const list& __x);
+# 641 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_assign_dispatch(__first, __last, _Integral());
+ }
+# 680 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      allocator_type
+      get_allocator() const
+      { return _Base::get_allocator(); }
+
+
+
+
+
+
+      iterator
+      begin()
+      { return iterator(this->_M_impl._M_node._M_next); }
+
+
+
+
+
+
+      const_iterator
+      begin() const
+      { return const_iterator(this->_M_impl._M_node._M_next); }
+
+
+
+
+
+
+      iterator
+      end()
+      { return iterator(&this->_M_impl._M_node); }
+
+
+
+
+
+
+      const_iterator
+      end() const
+      { return const_iterator(&this->_M_impl._M_node); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+
+
+
+
+
+
+      reverse_iterator
+      rend()
+      { return reverse_iterator(begin()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(begin()); }
+# 799 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      bool
+      empty() const
+      { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; }
+
+
+      size_type
+      size() const
+      { return std::distance(begin(), end()); }
+
+
+      size_type
+      max_size() const
+      { return _M_get_Node_allocator().max_size(); }
+# 823 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      resize(size_type __new_size, value_type __x = value_type());
+
+
+
+
+
+
+      reference
+      front()
+      { return *begin(); }
+
+
+
+
+
+      const_reference
+      front() const
+      { return *begin(); }
+
+
+
+
+
+      reference
+      back()
+      {
+ iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+
+
+
+
+
+      const_reference
+      back() const
+      {
+ const_iterator __tmp = end();
+ --__tmp;
+ return *__tmp;
+      }
+# 878 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      push_front(const value_type& __x)
+      { this->_M_insert(begin(), __x); }
+# 905 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      pop_front()
+      { this->_M_erase(begin()); }
+# 919 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      push_back(const value_type& __x)
+      { this->_M_insert(end(), __x); }
+# 945 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      pop_back()
+      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
+# 978 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      iterator
+      insert(iterator __position, const value_type& __x);
+# 1027 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      {
+ list __tmp(__n, __x, _M_get_Node_allocator());
+ splice(__position, __tmp);
+      }
+# 1047 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+   list __tmp(__first, __last, _M_get_Node_allocator());
+   splice(__position, __tmp);
+ }
+# 1071 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      iterator
+      erase(iterator __position);
+# 1092 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      iterator
+      erase(iterator __first, iterator __last)
+      {
+ while (__first != __last)
+   __first = erase(__first);
+ return __last;
+      }
+# 1109 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      swap(list& __x)
+      {
+ _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node);
+
+
+
+ std::__alloc_swap<typename _Base::_Node_alloc_type>::
+   _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator());
+      }
+
+
+
+
+
+
+
+      void
+      clear()
+      {
+        _Base::_M_clear();
+        _Base::_M_init();
+      }
+# 1145 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+
+
+
+      splice(iterator __position, list& __x)
+
+      {
+ if (!__x.empty())
+   {
+     _M_check_equal_allocators(__x);
+
+     this->_M_transfer(__position, __x.begin(), __x.end());
+   }
+      }
+# 1175 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+
+
+
+      splice(iterator __position, list& __x, iterator __i)
+
+      {
+ iterator __j = __i;
+ ++__j;
+ if (__position == __i || __position == __j)
+   return;
+
+ if (this != &__x)
+   _M_check_equal_allocators(__x);
+
+ this->_M_transfer(__position, __i, __j);
+      }
+# 1211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+
+
+
+
+      splice(iterator __position, list& __x, iterator __first,
+      iterator __last)
+
+      {
+ if (__first != __last)
+   {
+     if (this != &__x)
+       _M_check_equal_allocators(__x);
+
+     this->_M_transfer(__position, __first, __last);
+   }
+      }
+# 1246 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      remove(const _Tp& __value);
+# 1260 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      template<typename _Predicate>
+        void
+        remove_if(_Predicate);
+# 1274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      unique();
+# 1289 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      template<typename _BinaryPredicate>
+        void
+        unique(_BinaryPredicate);
+# 1310 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      merge(list& __x);
+# 1336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      template<typename _StrictWeakOrdering>
+        void
+        merge(list&, _StrictWeakOrdering);
+
+
+
+
+
+
+
+      void
+      reverse()
+      { this->_M_impl._M_node._M_reverse(); }
+
+
+
+
+
+
+
+      void
+      sort();
+
+
+
+
+
+
+
+      template<typename _StrictWeakOrdering>
+        void
+        sort(_StrictWeakOrdering);
+
+    public:
+
+
+
+
+
+
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+        { _M_fill_initialize(static_cast<size_type>(__n), __x); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+        {
+   for (; __first != __last; ++__first)
+     push_back(*__first);
+ }
+
+
+
+      void
+      _M_fill_initialize(size_type __n, const value_type& __x)
+      {
+ for (; __n > 0; --__n)
+   push_back(__x);
+      }
+# 1407 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type);
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+
+
+
+      void
+      _M_transfer(iterator __position, iterator __first, iterator __last)
+      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
+
+
+
+      void
+      _M_insert(iterator __position, const value_type& __x)
+      {
+        _Node* __tmp = _M_create_node(__x);
+        __tmp->_M_hook(__position._M_node);
+      }
+# 1448 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+      void
+      _M_erase(iterator __position)
+      {
+        __position._M_node->_M_unhook();
+        _Node* __n = static_cast<_Node*>(__position._M_node);
+
+
+
+ _M_get_Tp_allocator().destroy(&__n->_M_data);
+
+        _M_put_node(__n);
+      }
+
+
+      void
+      _M_check_equal_allocators(list& __x)
+      {
+ if (std::__alloc_neq<typename _Base::_Node_alloc_type>::
+     _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()))
+   __throw_runtime_error(("list::_M_check_equal_allocators"));
+      }
+    };
+# 1481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    {
+      typedef typename list<_Tp, _Alloc>::const_iterator const_iterator;
+      const_iterator __end1 = __x.end();
+      const_iterator __end2 = __y.end();
+
+      const_iterator __i1 = __x.begin();
+      const_iterator __i2 = __y.begin();
+      while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2)
+ {
+   ++__i1;
+   ++__i2;
+ }
+      return __i1 == __end1 && __i2 == __end2;
+    }
+# 1510 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_list.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
+    { __x.swap(__y); }
+
+}
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/list.tcc" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/list.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Tp, typename _Alloc>
+    void
+    _List_base<_Tp, _Alloc>::
+    _M_clear()
+    {
+      typedef _List_node<_Tp> _Node;
+      _Node* __cur = static_cast<_Node*>(this->_M_impl._M_node._M_next);
+      while (__cur != &this->_M_impl._M_node)
+ {
+   _Node* __tmp = __cur;
+   __cur = static_cast<_Node*>(__cur->_M_next);
+
+
+
+   _M_get_Tp_allocator().destroy(&__tmp->_M_data);
+
+   _M_put_node(__tmp);
+ }
+    }
+# 95 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/list.tcc" 3
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+    insert(iterator __position, const value_type& __x)
+    {
+      _Node* __tmp = _M_create_node(__x);
+      __tmp->_M_hook(__position._M_node);
+      return iterator(__tmp);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename list<_Tp, _Alloc>::iterator
+    list<_Tp, _Alloc>::
+    erase(iterator __position)
+    {
+      iterator __ret = iterator(__position._M_node->_M_next);
+      _M_erase(__position);
+      return __ret;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    resize(size_type __new_size, value_type __x)
+    {
+      iterator __i = begin();
+      size_type __len = 0;
+      for (; __i != end() && __len < __new_size; ++__i, ++__len)
+        ;
+      if (__len == __new_size)
+        erase(__i, end());
+      else
+        insert(end(), __new_size - __len, __x);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    list<_Tp, _Alloc>&
+    list<_Tp, _Alloc>::
+    operator=(const list& __x)
+    {
+      if (this != &__x)
+ {
+   iterator __first1 = begin();
+   iterator __last1 = end();
+   const_iterator __first2 = __x.begin();
+   const_iterator __last2 = __x.end();
+   for (; __first1 != __last1 && __first2 != __last2;
+        ++__first1, ++__first2)
+     *__first1 = *__first2;
+   if (__first2 == __last2)
+     erase(__first1, __last1);
+   else
+     insert(__last1, __first2, __last2);
+ }
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    _M_fill_assign(size_type __n, const value_type& __val)
+    {
+      iterator __i = begin();
+      for (; __i != end() && __n > 0; ++__i, --__n)
+        *__i = __val;
+      if (__n > 0)
+        insert(end(), __n, __val);
+      else
+        erase(__i, end());
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _InputIterator>
+      void
+      list<_Tp, _Alloc>::
+      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
+    __false_type)
+      {
+        iterator __first1 = begin();
+        iterator __last1 = end();
+        for (; __first1 != __last1 && __first2 != __last2;
+      ++__first1, ++__first2)
+          *__first1 = *__first2;
+        if (__first2 == __last2)
+          erase(__first1, __last1);
+        else
+          insert(__last1, __first2, __last2);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    remove(const value_type& __value)
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      iterator __extra = __last;
+      while (__first != __last)
+ {
+   iterator __next = __first;
+   ++__next;
+   if (*__first == __value)
+     {
+
+
+
+       if (&*__first != &__value)
+  _M_erase(__first);
+       else
+  __extra = __first;
+     }
+   __first = __next;
+ }
+      if (__extra != __last)
+ _M_erase(__extra);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    unique()
+    {
+      iterator __first = begin();
+      iterator __last = end();
+      if (__first == __last)
+ return;
+      iterator __next = __first;
+      while (++__next != __last)
+ {
+   if (*__first == *__next)
+     _M_erase(__next);
+   else
+     __first = __next;
+   __next = __first;
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+
+
+
+    merge(list& __x)
+
+    {
+
+
+      if (this != &__x)
+ {
+   _M_check_equal_allocators(__x);
+
+   iterator __first1 = begin();
+   iterator __last1 = end();
+   iterator __first2 = __x.begin();
+   iterator __last2 = __x.end();
+   while (__first1 != __last1 && __first2 != __last2)
+     if (*__first2 < *__first1)
+       {
+  iterator __next = __first2;
+  _M_transfer(__first1, __first2, ++__next);
+  __first2 = __next;
+       }
+     else
+       ++__first1;
+   if (__first2 != __last2)
+     _M_transfer(__last1, __first2, __last2);
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+
+
+
+      merge(list& __x, _StrictWeakOrdering __comp)
+
+      {
+
+
+ if (this != &__x)
+   {
+     _M_check_equal_allocators(__x);
+
+     iterator __first1 = begin();
+     iterator __last1 = end();
+     iterator __first2 = __x.begin();
+     iterator __last2 = __x.end();
+     while (__first1 != __last1 && __first2 != __last2)
+       if (__comp(*__first2, *__first1))
+  {
+    iterator __next = __first2;
+    _M_transfer(__first1, __first2, ++__next);
+    __first2 = __next;
+  }
+       else
+  ++__first1;
+     if (__first2 != __last2)
+       _M_transfer(__last1, __first2, __last2);
+   }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    list<_Tp, _Alloc>::
+    sort()
+    {
+
+      if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+   && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+      {
+        list __carry;
+        list __tmp[64];
+        list * __fill = &__tmp[0];
+        list * __counter;
+
+        do
+   {
+     __carry.splice(__carry.begin(), *this, begin());
+
+     for(__counter = &__tmp[0];
+  __counter != __fill && !__counter->empty();
+  ++__counter)
+       {
+  __counter->merge(__carry);
+  __carry.swap(*__counter);
+       }
+     __carry.swap(*__counter);
+     if (__counter == __fill)
+       ++__fill;
+   }
+ while ( !empty() );
+
+        for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
+          __counter->merge(*(__counter - 1));
+        swap( *(__fill - 1) );
+      }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _Predicate>
+      void
+      list<_Tp, _Alloc>::
+      remove_if(_Predicate __pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        while (__first != __last)
+   {
+     iterator __next = __first;
+     ++__next;
+     if (__pred(*__first))
+       _M_erase(__first);
+     __first = __next;
+   }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _BinaryPredicate>
+      void
+      list<_Tp, _Alloc>::
+      unique(_BinaryPredicate __binary_pred)
+      {
+        iterator __first = begin();
+        iterator __last = end();
+        if (__first == __last)
+   return;
+        iterator __next = __first;
+        while (++__next != __last)
+   {
+     if (__binary_pred(*__first, *__next))
+       _M_erase(__next);
+     else
+       __first = __next;
+     __next = __first;
+   }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template <typename _StrictWeakOrdering>
+      void
+      list<_Tp, _Alloc>::
+      sort(_StrictWeakOrdering __comp)
+      {
+
+ if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
+     && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
+   {
+     list __carry;
+     list __tmp[64];
+     list * __fill = &__tmp[0];
+     list * __counter;
+
+     do
+       {
+  __carry.splice(__carry.begin(), *this, begin());
+
+  for(__counter = &__tmp[0];
+      __counter != __fill && !__counter->empty();
+      ++__counter)
+    {
+      __counter->merge(__carry, __comp);
+      __carry.swap(*__counter);
+    }
+  __carry.swap(*__counter);
+  if (__counter == __fill)
+    ++__fill;
+       }
+     while ( !empty() );
+
+     for (__counter = &__tmp[1]; __counter != __fill; ++__counter)
+       __counter->merge(*(__counter - 1), __comp);
+     swap(*(__fill - 1));
+   }
+      }
+
+}
+# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/list" 2 3
+# 52 "/usr/include/qt4/QtCore/qlist.h" 2
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+template <typename T> class QVector;
+template <typename T> class QSet;
+
+struct QListData {
+    struct Data {
+        QBasicAtomicInt ref;
+        int alloc, begin, end;
+        uint sharable : 1;
+        void *array[1];
+    };
+    enum { DataHeaderSize = sizeof(Data) - sizeof(void *) };
+
+    Data *detach();
+    Data *detach2();
+    Data *detach3();
+    void realloc(int alloc);
+    static Data shared_null;
+    Data *d;
+    void **erase(void **xi);
+    void **append();
+    void **append(const QListData &l);
+    void **append2(const QListData &l);
+    void **prepend();
+    void **insert(int i);
+    void remove(int i);
+    void remove(int i, int n);
+    void move(int from, int to);
+    inline int size() const { return d->end - d->begin; }
+    inline bool isEmpty() const { return d->end == d->begin; }
+    inline void **at(int i) const { return d->array + d->begin + i; }
+    inline void **begin() const { return d->array + d->begin; }
+    inline void **end() const { return d->array + d->end; }
+};
+
+template <typename T>
+class QList
+{
+    struct Node { void *v;
+
+
+
+        inline T &t()
+        { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic
+                                       ? v : this); }
+
+    };
+
+    union { QListData p; QListData::Data *d; };
+
+public:
+    inline QList() : d(&QListData::shared_null) { d->ref.ref(); }
+    inline QList(const QList<T> &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+    ~QList();
+    QList<T> &operator=(const QList<T> &l);
+    bool operator==(const QList<T> &l) const;
+    inline bool operator!=(const QList<T> &l) const { return !(*this == l); }
+
+    inline int size() const { return p.size(); }
+
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+
+    inline void detachShared()
+    {
+
+        if (d->ref != 1 && this->d != &QListData::shared_null)
+            detach_helper();
+    }
+
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+
+    inline bool isEmpty() const { return p.isEmpty(); }
+
+    void clear();
+
+    const T &at(int i) const;
+    const T &operator[](int i) const;
+    T &operator[](int i);
+
+    void append(const T &t);
+    void append(const QList<T> &t);
+    void prepend(const T &t);
+    void insert(int i, const T &t);
+    void replace(int i, const T &t);
+    void removeAt(int i);
+    int removeAll(const T &t);
+    bool removeOne(const T &t);
+    T takeAt(int i);
+    T takeFirst();
+    T takeLast();
+    void move(int from, int to);
+    void swap(int i, int j);
+    int indexOf(const T &t, int from = 0) const;
+    int lastIndexOf(const T &t, int from = -1) const;
+    QBool contains(const T &t) const;
+    int count(const T &t) const;
+
+    class const_iterator;
+
+    class iterator {
+    public:
+        Node *i;
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef T *pointer;
+        typedef T &reference;
+
+        inline iterator() : i(0) {}
+        inline iterator(Node *n) : i(n) {}
+        inline iterator(const iterator &o): i(o.i){}
+        inline T &operator*() const { return i->t(); }
+        inline T *operator->() const { return &i->t(); }
+        inline T &operator[](int j) const { return i[j].t(); }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline bool operator<(const iterator& other) const { return i < other.i; }
+        inline bool operator<=(const iterator& other) const { return i <= other.i; }
+        inline bool operator>(const iterator& other) const { return i > other.i; }
+        inline bool operator>=(const iterator& other) const { return i >= other.i; }
+
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+        inline bool operator<(const const_iterator& other) const
+            { return i < other.i; }
+        inline bool operator<=(const const_iterator& other) const
+            { return i <= other.i; }
+        inline bool operator>(const const_iterator& other) const
+            { return i > other.i; }
+        inline bool operator>=(const const_iterator& other) const
+            { return i >= other.i; }
+
+        inline iterator &operator++() { ++i; return *this; }
+        inline iterator operator++(int) { Node *n = i; ++i; return n; }
+        inline iterator &operator--() { i--; return *this; }
+        inline iterator operator--(int) { Node *n = i; i--; return n; }
+        inline iterator &operator+=(int j) { i+=j; return *this; }
+        inline iterator &operator-=(int j) { i-=j; return *this; }
+        inline iterator operator+(int j) const { return iterator(i+j); }
+        inline iterator operator-(int j) const { return iterator(i-j); }
+        inline int operator-(iterator j) const { return int(i - j.i); }
+    };
+    friend class iterator;
+
+    class const_iterator {
+    public:
+        Node *i;
+        typedef std::random_access_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+
+        inline const_iterator() : i(0) {}
+        inline const_iterator(Node *n) : i(n) {}
+        inline const_iterator(const const_iterator &o): i(o.i) {}
+
+
+
+        inline const_iterator(const iterator &o): i(o.i) {}
+
+        inline const T &operator*() const { return i->t(); }
+        inline const T *operator->() const { return &i->t(); }
+        inline const T &operator[](int j) const { return i[j].t(); }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline bool operator<(const const_iterator& other) const { return i < other.i; }
+        inline bool operator<=(const const_iterator& other) const { return i <= other.i; }
+        inline bool operator>(const const_iterator& other) const { return i > other.i; }
+        inline bool operator>=(const const_iterator& other) const { return i >= other.i; }
+        inline const_iterator &operator++() { ++i; return *this; }
+        inline const_iterator operator++(int) { Node *n = i; ++i; return n; }
+        inline const_iterator &operator--() { i--; return *this; }
+        inline const_iterator operator--(int) { Node *n = i; i--; return n; }
+        inline const_iterator &operator+=(int j) { i+=j; return *this; }
+        inline const_iterator &operator-=(int j) { i-=j; return *this; }
+        inline const_iterator operator+(int j) const { return const_iterator(i+j); }
+        inline const_iterator operator-(int j) const { return const_iterator(i-j); }
+        inline int operator-(const_iterator j) const { return i - j.i; }
+    };
+    friend class const_iterator;
+
+
+    inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); }
+    inline const_iterator begin() const { return reinterpret_cast<Node *>(p.begin()); }
+    inline const_iterator constBegin() const { return reinterpret_cast<Node *>(p.begin()); }
+    inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); }
+    inline const_iterator end() const { return reinterpret_cast<Node *>(p.end()); }
+    inline const_iterator constEnd() const { return reinterpret_cast<Node *>(p.end()); }
+    iterator insert(iterator before, const T &t);
+    iterator erase(iterator pos);
+    iterator erase(iterator first, iterator last);
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return p.size(); }
+    inline int length() const { return p.size(); }
+    inline T& first() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",263) : qt_noop()); return *begin(); }
+    inline const T& first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",264) : qt_noop()); return *begin(); }
+    T& last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",265) : qt_noop()); return *(--end()); }
+    const T& last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",266) : qt_noop()); return *(--end()); }
+    inline void removeFirst() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",267) : qt_noop()); erase(begin()); }
+    inline void removeLast() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qlist.h",268) : qt_noop()); erase(--end()); }
+    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
+    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
+    QList<T> mid(int pos, int length = -1) const;
+
+    T value(int i) const;
+    T value(int i, const T &defaultValue) const;
+
+
+    inline void push_back(const T &t) { append(t); }
+    inline void push_front(const T &t) { prepend(t); }
+    inline T& front() { return first(); }
+    inline const T& front() const { return first(); }
+    inline T& back() { return last(); }
+    inline const T& back() const { return last(); }
+    inline void pop_front() { removeFirst(); }
+    inline void pop_back() { removeLast(); }
+    inline bool empty() const { return isEmpty(); }
+    typedef int size_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef ptrdiff_t difference_type;
+# 309 "/usr/include/qt4/QtCore/qlist.h"
+    QList<T> &operator+=(const QList<T> &l);
+    inline QList<T> operator+(const QList<T> &l) const
+    { QList n = *this; n += l; return n; }
+    inline QList<T> &operator+=(const T &t)
+    { append(t); return *this; }
+    inline QList<T> &operator<< (const T &t)
+    { append(t); return *this; }
+    inline QList<T> &operator<<(const QList<T> &l)
+    { *this += l; return *this; }
+
+    QVector<T> toVector() const;
+    QSet<T> toSet() const;
+
+    static QList<T> fromVector(const QVector<T> &vector);
+    static QList<T> fromSet(const QSet<T> &set);
+
+
+    static inline QList<T> fromStdList(const std::list<T> &list)
+    { QList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; }
+    inline std::list<T> toStdList() const
+    { std::list<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }
+
+
+private:
+    void detach_helper();
+    void free(QListData::Data *d);
+
+    void node_construct(Node *n, const T &t);
+    void node_destruct(Node *n);
+    void node_copy(Node *from, Node *to, Node *src);
+    void node_destruct(Node *from, Node *to);
+};
+
+
+
+
+
+
+
+template <typename T>
+inline void QList<T>::node_construct(Node *n, const T &t)
+{
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t);
+    else if (QTypeInfo<T>::isComplex) new (n) T(t);
+    else *reinterpret_cast<T*>(n) = t;
+}
+
+template <typename T>
+inline void QList<T>::node_destruct(Node *n)
+{
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v);
+    else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T();
+}
+
+template <typename T>
+inline void QList<T>::node_copy(Node *from, Node *to, Node *src)
+{
+    Node *current = from;
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+        try {
+            while(current != to) {
+                current->v = new T(*reinterpret_cast<T*>(src->v));
+                ++current;
+                ++src;
+            }
+        } catch (...) {
+            while (current-- != from)
+                delete reinterpret_cast<T*>(current->v);
+            throw;
+        }
+
+    } else if (QTypeInfo<T>::isComplex) {
+        try {
+            while(current != to) {
+                new (current) T(*reinterpret_cast<T*>(src));
+                ++current;
+                ++src;
+            }
+        } catch (...) {
+            while (current-- != from)
+                (reinterpret_cast<T*>(current))->~T();
+            throw;
+        }
+    } else {
+        if (src != from && to - from > 0)
+            memcpy(from, src, (to - from) * sizeof(Node *));
+    }
+}
+
+template <typename T>
+inline void QList<T>::node_destruct(Node *from, Node *to)
+{
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic)
+        while(from != to) --to, delete reinterpret_cast<T*>(to->v);
+    else if (QTypeInfo<T>::isComplex)
+        while (from != to) --to, reinterpret_cast<T*>(to)->~T();
+}
+
+template <typename T>
+inline QList<T> &QList<T>::operator=(const QList<T> &l)
+{
+    if (d != l.d) {
+        l.d->ref.ref();
+        if (!d->ref.deref())
+            free(d);
+        d = l.d;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+template <typename T>
+inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t)
+{
+    int iBefore = int(before.i - reinterpret_cast<Node *>(p.begin()));
+    Node *n = reinterpret_cast<Node *>(p.insert(iBefore));
+    try {
+        node_construct(n, t);
+    } catch (...) {
+        p.remove(iBefore);
+        throw;
+    }
+    return n;
+}
+template <typename T>
+inline typename QList<T>::iterator QList<T>::erase(iterator it)
+{ node_destruct(it.i);
+ return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i))); }
+template <typename T>
+inline const T &QList<T>::at(int i) const
+{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::at", "index out of range","/usr/include/qt4/QtCore/qlist.h",439) : qt_noop());
+ return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline const T &QList<T>::operator[](int i) const
+{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qlist.h",443) : qt_noop());
+ return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline T &QList<T>::operator[](int i)
+{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qlist.h",447) : qt_noop());
+  detach(); return reinterpret_cast<Node *>(p.at(i))->t(); }
+template <typename T>
+inline void QList<T>::removeAt(int i)
+{ if(i >= 0 && i < p.size()) { detach();
+ node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i); } }
+template <typename T>
+inline T QList<T>::takeAt(int i)
+{ ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::take", "index out of range","/usr/include/qt4/QtCore/qlist.h",455) : qt_noop());
+ detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = n->t(); node_destruct(n);
+ p.remove(i); return t; }
+template <typename T>
+inline T QList<T>::takeFirst()
+{ T t = first(); removeFirst(); return t; }
+template <typename T>
+inline T QList<T>::takeLast()
+{ T t = last(); removeLast(); return t; }
+
+template <typename T>
+ void QList<T>::append(const T &t)
+{
+    detach();
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+        Node *n = reinterpret_cast<Node *>(p.append());
+        try {
+            node_construct(n, t);
+        } catch (...) {
+            --d->end;
+            throw;
+        }
+    } else {
+        const T cpy(t);
+        Node *n = reinterpret_cast<Node *>(p.append());
+        try {
+            node_construct(n, cpy);
+        } catch (...) {
+            --d->end;
+            throw;
+        }
+    }
+}
+
+template <typename T>
+inline void QList<T>::prepend(const T &t)
+{
+    detach();
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+        Node *n = reinterpret_cast<Node *>(p.prepend());
+        try {
+            node_construct(n, t);
+        } catch (...) {
+            ++d->begin;
+            throw;
+        }
+    } else {
+        const T cpy(t);
+        Node *n = reinterpret_cast<Node *>(p.prepend());
+        try {
+            node_construct(n, cpy);
+        } catch (...) {
+            ++d->begin;
+            throw;
+        }
+    }
+}
+
+template <typename T>
+inline void QList<T>::insert(int i, const T &t)
+{
+    detach();
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+        Node *n = reinterpret_cast<Node *>(p.insert(i));
+        try {
+            node_construct(n, t);
+        } catch (...) {
+            p.remove(i);
+            throw;
+        }
+    } else {
+        const T cpy(t);
+        Node *n = reinterpret_cast<Node *>(p.insert(i));
+        try {
+            node_construct(n, cpy);
+        } catch (...) {
+            p.remove(i);
+            throw;
+        }
+    }
+}
+
+template <typename T>
+inline void QList<T>::replace(int i, const T &t)
+{
+    ((!(i >= 0 && i < p.size())) ? qt_assert_x("QList<T>::replace", "index out of range","/usr/include/qt4/QtCore/qlist.h",540) : qt_noop());
+    detach();
+    if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) {
+        reinterpret_cast<Node *>(p.at(i))->t() = t;
+    } else {
+        const T cpy(t);
+        reinterpret_cast<Node *>(p.at(i))->t() = cpy;
+    }
+}
+
+template <typename T>
+inline void QList<T>::swap(int i, int j)
+{
+    ((!(i >= 0 && i < p.size() && j >= 0 && j < p.size())) ? qt_assert_x("QList<T>::swap", "index out of range",
+ "/usr/include/qt4/QtCore/qlist.h"
+# 553 "/usr/include/qt4/QtCore/qlist.h"
+    ,
+ 554
+# 553 "/usr/include/qt4/QtCore/qlist.h"
+    ) : qt_noop())
+                                                       ;
+    detach();
+    void *t = d->array[d->begin + i];
+    d->array[d->begin + i] = d->array[d->begin + j];
+    d->array[d->begin + j] = t;
+}
+
+template <typename T>
+inline void QList<T>::move(int from, int to)
+{
+    ((!(from >= 0 && from < p.size() && to >= 0 && to < p.size())) ? qt_assert_x("QList<T>::move", "index out of range",
+ "/usr/include/qt4/QtCore/qlist.h"
+# 564 "/usr/include/qt4/QtCore/qlist.h"
+    ,
+ 565
+# 564 "/usr/include/qt4/QtCore/qlist.h"
+    ) : qt_noop())
+                                                      ;
+    detach();
+    p.move(from, to);
+}
+
+template<typename T>
+ QList<T> QList<T>::mid(int pos, int alength) const
+{
+    if (alength < 0)
+        alength = size() - pos;
+    if (pos == 0 && alength == size())
+        return *this;
+    QList<T> cpy;
+    if (pos + alength > size())
+        alength = size() - pos;
+    for (int i = pos; i < pos + alength; ++i)
+        cpy += at(i);
+    return cpy;
+}
+
+template<typename T>
+ T QList<T>::value(int i) const
+{
+    if (i < 0 || i >= p.size()) {
+        return T();
+    }
+    return reinterpret_cast<Node *>(p.at(i))->t();
+}
+
+template<typename T>
+ T QList<T>::value(int i, const T& defaultValue) const
+{
+    return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t());
+}
+
+template <typename T>
+ void QList<T>::detach_helper()
+{
+    Node *n = reinterpret_cast<Node *>(p.begin());
+    QListData::Data *x = p.detach3();
+    try {
+        node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n);
+    } catch (...) {
+        qFree(d);
+        d = x;
+        throw;
+    }
+
+    if (!x->ref.deref())
+        free(x);
+}
+
+template <typename T>
+ QList<T>::~QList()
+{
+    if (d && !d->ref.deref())
+        free(d);
+}
+
+template <typename T>
+ bool QList<T>::operator==(const QList<T> &l) const
+{
+    if (p.size() != l.p.size())
+        return false;
+    if (d == l.d)
+        return true;
+    Node *i = reinterpret_cast<Node *>(p.end());
+    Node *b = reinterpret_cast<Node *>(p.begin());
+    Node *li = reinterpret_cast<Node *>(l.p.end());
+    while (i != b) {
+        --i; --li;
+        if (!(i->t() == li->t()))
+            return false;
+    }
+    return true;
+}
+
+
+template <typename T>
+ void QList<T>::free(QListData::Data *data)
+{
+    node_destruct(reinterpret_cast<Node *>(data->array + data->begin),
+                  reinterpret_cast<Node *>(data->array + data->end));
+    if (data->ref == 0)
+        qFree(data);
+}
+
+
+template <typename T>
+ void QList<T>::clear()
+{
+    *this = QList<T>();
+}
+
+template <typename T>
+ int QList<T>::removeAll(const T &_t)
+{
+    detachShared();
+    const T t = _t;
+    int removedCount=0, i=0;
+    Node *n;
+    while (i < p.size())
+        if ((n = reinterpret_cast<Node *>(p.at(i)))->t() == t) {
+            node_destruct(n);
+            p.remove(i);
+            ++removedCount;
+        } else {
+            ++i;
+        }
+    return removedCount;
+}
+
+template <typename T>
+ bool QList<T>::removeOne(const T &_t)
+{
+    detachShared();
+    int index = indexOf(_t);
+    if (index != -1) {
+        removeAt(index);
+        return true;
+    }
+    return false;
+}
+
+template <typename T>
+ typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst,
+                                                                 typename QList<T>::iterator alast)
+{
+    for (Node *n = afirst.i; n < alast.i; ++n)
+        node_destruct(n);
+    int idx = afirst - begin();
+    p.remove(idx, alast - afirst);
+    return begin() + idx;
+}
+
+template <typename T>
+ QList<T> &QList<T>::operator+=(const QList<T> &l)
+{
+    detach();
+    Node *n = reinterpret_cast<Node *>(p.append2(l.p));
+    try{
+        node_copy(n, reinterpret_cast<Node *>(p.end()), reinterpret_cast<Node *>(l.p.begin()));
+    } catch (...) {
+
+        d->end -= int(reinterpret_cast<Node *>(p.end()) - n);
+        throw;
+    }
+    return *this;
+}
+
+template <typename T>
+inline void QList<T>::append(const QList<T> &t)
+{
+    *this += t;
+}
+
+template <typename T>
+ int QList<T>::indexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from = qMax(from + p.size(), 0);
+    if (from < p.size()) {
+        Node *n = reinterpret_cast<Node *>(p.at(from -1));
+        Node *e = reinterpret_cast<Node *>(p.end());
+        while (++n != e)
+            if (n->t() == t)
+                return int(n - reinterpret_cast<Node *>(p.begin()));
+    }
+    return -1;
+}
+
+template <typename T>
+ int QList<T>::lastIndexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from += p.size();
+    else if (from >= p.size())
+        from = p.size()-1;
+    if (from >= 0) {
+        Node *b = reinterpret_cast<Node *>(p.begin());
+        Node *n = reinterpret_cast<Node *>(p.at(from + 1));
+        while (n-- != b) {
+            if (n->t() == t)
+                return n - b;
+        }
+    }
+    return -1;
+}
+
+template <typename T>
+ QBool QList<T>::contains(const T &t) const
+{
+    Node *b = reinterpret_cast<Node *>(p.begin());
+    Node *i = reinterpret_cast<Node *>(p.end());
+    while (i-- != b)
+        if (i->t() == t)
+            return QBool(true);
+    return QBool(false);
+}
+
+template <typename T>
+ int QList<T>::count(const T &t) const
+{
+    int c = 0;
+    Node *b = reinterpret_cast<Node *>(p.begin());
+    Node *i = reinterpret_cast<Node *>(p.end());
+    while (i-- != b)
+        if (i->t() == t)
+            ++c;
+    return c;
+}
+
+template <class T> class QListIterator { typedef typename QList<T>::const_iterator const_iterator; QList<T> c; const_iterator i; public: inline QListIterator(const QList<T> &container) : c(container), i(c.constBegin()) {} inline QListIterator &operator=(const QList<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+template <class T> class QMutableListIterator { typedef typename QList<T>::iterator iterator; typedef typename QList<T>::const_iterator const_iterator; QList<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableListIterator(QList<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableListIterator() { c->setSharable(true); } inline QMutableListIterator &operator=(QList<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qlist.h",778) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qlist.h",778) : qt_noop()); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+
+
+
+
+# 51 "/usr/include/qt4/QtCore/qobject.h" 2
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QEvent;
+class QTimerEvent;
+class QChildEvent;
+struct QMetaObject;
+class QVariant;
+class QObjectPrivate;
+class QObject;
+class QThread;
+class QWidget;
+
+class QRegExp;
+
+
+class QObjectUserData;
+
+
+typedef QList<QObject*> QObjectList;
+# 87 "/usr/include/qt4/QtCore/qobject.h"
+template<typename T> inline T qFindChild(const QObject *, const QString & = QString());
+template<typename T> inline QList<T> qFindChildren(const QObject *, const QString & = QString());
+
+template<typename T> inline QList<T> qFindChildren(const QObject *, const QRegExp &);
+
+
+
+class
+
+
+
+QObjectData {
+public:
+    virtual ~QObjectData() = 0;
+    QObject *q_ptr;
+    QObject *parent;
+    QObjectList children;
+
+    uint isWidget : 1;
+    uint pendTimer : 1;
+    uint blockSig : 1;
+    uint wasDeleted : 1;
+    uint ownObjectName : 1;
+    uint sendChildEvents : 1;
+    uint receiveChildEvents : 1;
+    uint inEventHandler : 1;
+    uint inThreadChangeEvent : 1;
+    uint hasGuards : 1;
+    uint unused : 22;
+    int postedEvents;
+    QMetaObject *metaObject;
+};
+
+
+class QObject
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private:
+   
+    inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate *>(qGetPtrHelper(d_ptr)); } inline const QObjectPrivate* d_func() const { return reinterpret_cast<const QObjectPrivate *>(qGetPtrHelper(d_ptr)); } friend class QObjectPrivate;
+
+public:
+    explicit QObject(QObject *parent=0);
+    virtual ~QObject();
+
+    virtual bool event(QEvent *);
+    virtual bool eventFilter(QObject *, QEvent *);
+# 153 "/usr/include/qt4/QtCore/qobject.h"
+    QString objectName() const;
+    void setObjectName(const QString &name);
+
+    inline bool isWidgetType() const { return d_ptr->isWidget; }
+
+    inline bool signalsBlocked() const { return d_ptr->blockSig; }
+    bool blockSignals(bool b);
+
+    QThread *thread() const;
+    void moveToThread(QThread *thread);
+
+    int startTimer(int interval);
+    void killTimer(int id);
+
+
+    template<typename T>
+    inline T findChild(const QString &aName = QString()) const
+    { return qFindChild<T>(this, aName); }
+
+    template<typename T>
+    inline QList<T> findChildren(const QString &aName = QString()) const
+    { return qFindChildren<T>(this, aName); }
+
+
+    template<typename T>
+    inline QList<T> findChildren(const QRegExp &re) const
+    { return qFindChildren<T>(this, re); }
+# 191 "/usr/include/qt4/QtCore/qobject.h"
+    inline const QObjectList &children() const { return d_ptr->children; }
+
+    void setParent(QObject *);
+    void installEventFilter(QObject *);
+    void removeEventFilter(QObject *);
+
+
+    static bool connect(const QObject *sender, const char *signal,
+                        const QObject *receiver, const char *member, Qt::ConnectionType =
+
+
+
+
+
+
+                        Qt::AutoConnection
+
+
+        );
+    inline bool connect(const QObject *sender, const char *signal,
+                        const char *member, Qt::ConnectionType type =
+
+
+
+
+
+
+                        Qt::AutoConnection
+
+
+        ) const;
+
+    static bool disconnect(const QObject *sender, const char *signal,
+                           const QObject *receiver, const char *member);
+    inline bool disconnect(const char *signal = 0,
+                           const QObject *receiver = 0, const char *member = 0)
+        { return disconnect(this, signal, receiver, member); }
+    inline bool disconnect(const QObject *receiver, const char *member = 0)
+        { return disconnect(this, 0, receiver, member); }
+
+    void dumpObjectTree();
+    void dumpObjectInfo();
+
+
+    bool setProperty(const char *name, const QVariant &value);
+    QVariant property(const char *name) const;
+    QList<QByteArray> dynamicPropertyNames() const;
+
+
+
+    static uint registerUserData();
+    void setUserData(uint id, QObjectUserData* data);
+    QObjectUserData* userData(uint id) const;
+
+
+public:
+    void destroyed(QObject * = 0);
+
+public:
+    inline QObject *parent() const { return d_ptr->parent; }
+
+    inline bool inherits(const char *classname) const
+        { return const_cast<QObject *>(this)->qt_metacast(classname) != 0; }
+
+public :
+    void deleteLater();
+
+public:
+    QObject *sender() const;
+    int receivers(const char* signal) const;
+
+    virtual void timerEvent(QTimerEvent *);
+    virtual void childEvent(QChildEvent *);
+    virtual void customEvent(QEvent *);
+
+    virtual void connectNotify(const char *signal);
+    virtual void disconnectNotify(const char *signal);
+# 292 "/usr/include/qt4/QtCore/qobject.h"
+public:
+    QObject(QObjectPrivate &dd, QObject *parent = 0);
+
+public:
+    QScopedPointer<QObjectData> d_ptr;
+
+    static const QMetaObject staticQtMetaObject;
+
+    friend struct QMetaObject;
+    friend class QApplication;
+    friend class QApplicationPrivate;
+    friend class QCoreApplication;
+    friend class QCoreApplicationPrivate;
+    friend class QWidget;
+    friend class QThreadData;
+
+private:
+    QObject(const QObject &); QObject &operator=(const QObject &);
+   
+};
+
+inline bool QObject::connect(const QObject *asender, const char *asignal,
+                             const char *amember, Qt::ConnectionType atype) const
+{ return connect(asender, asignal, this, amember, atype); }
+
+
+class QObjectUserData {
+public:
+    virtual ~QObjectUserData();
+};
+
+
+ void qt_qFindChildren_helper(const QObject *parent, const QString &name, const QRegExp *re,
+                                           const QMetaObject &mo, QList<void *> *list);
+ QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo);
+# 417 "/usr/include/qt4/QtCore/qobject.h"
+template<typename T>
+inline T qFindChild(const QObject *o, const QString &name)
+{ return static_cast<T>(qt_qFindChild_helper(o, name, reinterpret_cast<T>(0)->staticMetaObject)); }
+
+template<typename T>
+inline QList<T> qFindChildren(const QObject *o, const QString &name)
+{
+    QList<T> list;
+    union {
+        QList<T> *typedList;
+        QList<void *> *voidList;
+    } u;
+    u.typedList = &list;
+    qt_qFindChildren_helper(o, name, 0, reinterpret_cast<T>(0)->staticMetaObject, u.voidList);
+    return list;
+}
+
+
+template<typename T>
+inline QList<T> qFindChildren(const QObject *o, const QRegExp &re)
+{
+    QList<T> list;
+    union {
+        QList<T> *typedList;
+        QList<void *> *voidList;
+    } u;
+    u.typedList = &list;
+    qt_qFindChildren_helper(o, QString(), &re, reinterpret_cast<T>(0)->staticMetaObject, u.voidList);
+    return list;
+}
+
+
+template <class T>
+inline T qobject_cast(QObject *object)
+{
+
+    reinterpret_cast<T>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(object));
+
+    return static_cast<T>(reinterpret_cast<T>(0)->staticMetaObject.cast(object));
+}
+
+template <class T>
+inline T qobject_cast(const QObject *object)
+{
+
+    register T ptr = static_cast<T>(object);
+    (void)ptr;;
+
+
+    reinterpret_cast<T>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(const_cast<QObject *>(object)));
+
+    return static_cast<T>(const_cast<QObject *>(reinterpret_cast<T>(0)->staticMetaObject.cast(const_cast<QObject *>(object))));
+}
+
+
+template <class T> inline const char * qobject_interface_iid()
+{ return 0; }
+# 488 "/usr/include/qt4/QtCore/qobject.h"
+ QDebug operator<<(QDebug, const QObject *);
+
+
+
+
+
+# 47 "/usr/include/qt4/QtCore/qiodevice.h" 2
+# 57 "/usr/include/qt4/QtCore/qiodevice.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QByteArray;
+class QIODevicePrivate;
+
+class QIODevice
+
+    : public QObject
+
+{
+
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private:
+
+public:
+    enum OpenModeFlag {
+        NotOpen = 0x0000,
+        ReadOnly = 0x0001,
+        WriteOnly = 0x0002,
+        ReadWrite = ReadOnly | WriteOnly,
+        Append = 0x0004,
+        Truncate = 0x0008,
+        Text = 0x0010,
+        Unbuffered = 0x0020
+    };
+    typedef QFlags<OpenModeFlag> OpenMode;
+
+    QIODevice();
+
+    explicit QIODevice(QObject *parent);
+
+    virtual ~QIODevice();
+
+    OpenMode openMode() const;
+
+    void setTextModeEnabled(bool enabled);
+    bool isTextModeEnabled() const;
+
+    bool isOpen() const;
+    bool isReadable() const;
+    bool isWritable() const;
+    virtual bool isSequential() const;
+
+    virtual bool open(OpenMode mode);
+    virtual void close();
+
+
+
+    virtual qint64 pos() const;
+    virtual qint64 size() const;
+    virtual bool seek(qint64 pos);
+    virtual bool atEnd() const;
+    virtual bool reset();
+
+    virtual qint64 bytesAvailable() const;
+    virtual qint64 bytesToWrite() const;
+
+    qint64 read(char *data, qint64 maxlen);
+    QByteArray read(qint64 maxlen);
+    QByteArray readAll();
+    qint64 readLine(char *data, qint64 maxlen);
+    QByteArray readLine(qint64 maxlen = 0);
+    virtual bool canReadLine() const;
+
+    qint64 write(const char *data, qint64 len);
+    qint64 write(const char *data);
+    inline qint64 write(const QByteArray &data)
+    { return write(data.constData(), data.size()); }
+
+    qint64 peek(char *data, qint64 maxlen);
+    QByteArray peek(qint64 maxlen);
+
+    virtual bool waitForReadyRead(int msecs);
+    virtual bool waitForBytesWritten(int msecs);
+
+    void ungetChar(char c);
+    bool putChar(char c);
+    bool getChar(char *c);
+
+    QString errorString() const;
+
+
+public:
+    void readyRead();
+    void bytesWritten(qint64 bytes);
+    void aboutToClose();
+    void readChannelFinished();
+
+
+public:
+
+
+
+    QIODevice(QIODevicePrivate &dd, QObject *parent = 0);
+
+    virtual qint64 readData(char *data, qint64 maxlen) = 0;
+    virtual qint64 readLineData(char *data, qint64 maxlen);
+    virtual qint64 writeData(const char *data, qint64 len) = 0;
+
+    void setOpenMode(OpenMode openMode);
+
+    void setErrorString(const QString &errorString);
+
+
+
+
+
+private:
+    inline QIODevicePrivate* d_func() { return reinterpret_cast<QIODevicePrivate *>(qGetPtrHelper(d_ptr)); } inline const QIODevicePrivate* d_func() const { return reinterpret_cast<const QIODevicePrivate *>(qGetPtrHelper(d_ptr)); } friend class QIODevicePrivate;
+    QIODevice(const QIODevice &); QIODevice &operator=(const QIODevice &);
+# 204 "/usr/include/qt4/QtCore/qiodevice.h"
+};
+
+inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QIODevice::OpenMode::enum_type f2) { return QFlags<QIODevice::OpenMode::enum_type>(f1) | f2; } inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QFlags<QIODevice::OpenMode::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+# 246 "/usr/include/qt4/QtCore/qiodevice.h"
+class QDebug;
+ QDebug operator<<(QDebug debug, QIODevice::OpenMode modes);
+
+
+
+
+
+# 47 "/usr/include/qt4/QtCore/qdatastream.h" 2
+
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QByteArray;
+class QIODevice;
+
+template <typename T> class QList;
+template <typename T> class QLinkedList;
+template <typename T> class QVector;
+template <typename T> class QSet;
+template <class Key, class T> class QHash;
+template <class Key, class T> class QMap;
+
+
+class QDataStreamPrivate;
+class QDataStream
+{
+public:
+    enum Version {
+        Qt_1_0 = 1,
+        Qt_2_0 = 2,
+        Qt_2_1 = 3,
+        Qt_3_0 = 4,
+        Qt_3_1 = 5,
+        Qt_3_3 = 6,
+        Qt_4_0 = 7,
+        Qt_4_1 = Qt_4_0,
+        Qt_4_2 = 8,
+        Qt_4_3 = 9,
+        Qt_4_4 = 10,
+        Qt_4_5 = 11,
+        Qt_4_6 = 12
+
+
+
+
+    };
+
+    enum ByteOrder {
+        BigEndian = QSysInfo::BigEndian,
+        LittleEndian = QSysInfo::LittleEndian
+    };
+
+    enum Status {
+        Ok,
+        ReadPastEnd,
+ ReadCorruptData
+    };
+
+    enum FloatingPointPrecision {
+        SinglePrecision,
+        DoublePrecision
+    };
+
+    QDataStream();
+    explicit QDataStream(QIODevice *);
+
+
+
+    QDataStream(QByteArray *, QIODevice::OpenMode flags);
+    QDataStream(const QByteArray &);
+    virtual ~QDataStream();
+
+    QIODevice *device() const;
+    void setDevice(QIODevice *);
+    void unsetDevice();
+
+    bool atEnd() const;
+
+
+
+
+    Status status() const;
+    void setStatus(Status status);
+    void resetStatus();
+
+    FloatingPointPrecision floatingPointPrecision() const;
+    void setFloatingPointPrecision(FloatingPointPrecision precision);
+
+    ByteOrder byteOrder() const;
+    void setByteOrder(ByteOrder);
+
+    int version() const;
+    void setVersion(int);
+
+    QDataStream &operator>>(qint8 &i);
+    QDataStream &operator>>(quint8 &i);
+    QDataStream &operator>>(qint16 &i);
+    QDataStream &operator>>(quint16 &i);
+    QDataStream &operator>>(qint32 &i);
+    QDataStream &operator>>(quint32 &i);
+    QDataStream &operator>>(qint64 &i);
+    QDataStream &operator>>(quint64 &i);
+
+    QDataStream &operator>>(bool &i);
+    QDataStream &operator>>(float &f);
+    QDataStream &operator>>(double &f);
+    QDataStream &operator>>(char *&str);
+
+    QDataStream &operator<<(qint8 i);
+    QDataStream &operator<<(quint8 i);
+    QDataStream &operator<<(qint16 i);
+    QDataStream &operator<<(quint16 i);
+    QDataStream &operator<<(qint32 i);
+    QDataStream &operator<<(quint32 i);
+    QDataStream &operator<<(qint64 i);
+    QDataStream &operator<<(quint64 i);
+    QDataStream &operator<<(bool i);
+    QDataStream &operator<<(float f);
+    QDataStream &operator<<(double f);
+    QDataStream &operator<<(const char *str);
+
+    QDataStream &readBytes(char *&, uint &len);
+    int readRawData(char *, int len);
+
+    QDataStream &writeBytes(const char *, uint len);
+    int writeRawData(const char *, int len);
+
+    int skipRawData(int len);
+# 185 "/usr/include/qt4/QtCore/qdatastream.h"
+private:
+    QDataStream(const QDataStream &); QDataStream &operator=(const QDataStream &);
+
+    QScopedPointer<QDataStreamPrivate> d;
+
+    QIODevice *dev;
+    bool owndev;
+    bool noswap;
+    ByteOrder byteorder;
+    int ver;
+    Status q_status;
+};
+
+
+
+
+
+
+inline QIODevice *QDataStream::device() const
+{ return dev; }
+
+inline QDataStream::ByteOrder QDataStream::byteOrder() const
+{ return byteorder; }
+
+inline int QDataStream::version() const
+{ return ver; }
+
+inline void QDataStream::setVersion(int v)
+{ ver = v; }
+
+inline QDataStream &QDataStream::operator>>(quint8 &i)
+{ return *this >> reinterpret_cast<qint8&>(i); }
+
+inline QDataStream &QDataStream::operator>>(quint16 &i)
+{ return *this >> reinterpret_cast<qint16&>(i); }
+
+inline QDataStream &QDataStream::operator>>(quint32 &i)
+{ return *this >> reinterpret_cast<qint32&>(i); }
+
+inline QDataStream &QDataStream::operator>>(quint64 &i)
+{ return *this >> reinterpret_cast<qint64&>(i); }
+
+inline QDataStream &QDataStream::operator<<(quint8 i)
+{ return *this << qint8(i); }
+
+inline QDataStream &QDataStream::operator<<(quint16 i)
+{ return *this << qint16(i); }
+
+inline QDataStream &QDataStream::operator<<(quint32 i)
+{ return *this << qint32(i); }
+
+inline QDataStream &QDataStream::operator<<(quint64 i)
+{ return *this << qint64(i); }
+
+template <typename T>
+QDataStream& operator>>(QDataStream& s, QList<T>& l)
+{
+    l.clear();
+    quint32 c;
+    s >> c;
+    for(quint32 i = 0; i < c; ++i)
+    {
+        T t;
+        s >> t;
+        l.append(t);
+        if (s.atEnd())
+            break;
+    }
+    return s;
+}
+
+template <typename T>
+QDataStream& operator<<(QDataStream& s, const QList<T>& l)
+{
+    s << quint32(l.size());
+    for (int i = 0; i < l.size(); ++i)
+        s << l.at(i);
+    return s;
+}
+
+template <typename T>
+QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l)
+{
+    l.clear();
+    quint32 c;
+    s >> c;
+    for(quint32 i = 0; i < c; ++i)
+    {
+        T t;
+        s >> t;
+        l.append(t);
+        if (s.atEnd())
+            break;
+    }
+    return s;
+}
+
+template <typename T>
+QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l)
+{
+    s << quint32(l.size());
+    typename QLinkedList<T>::ConstIterator it = l.constBegin();
+    for(; it != l.constEnd(); ++it)
+        s << *it;
+    return s;
+}
+
+template<typename T>
+QDataStream& operator>>(QDataStream& s, QVector<T>& v)
+{
+    v.clear();
+    quint32 c;
+    s >> c;
+    v.resize(c);
+    for(quint32 i = 0; i < c; ++i) {
+        T t;
+        s >> t;
+        v[i] = t;
+    }
+    return s;
+}
+
+template<typename T>
+QDataStream& operator<<(QDataStream& s, const QVector<T>& v)
+{
+    s << quint32(v.size());
+    for (typename QVector<T>::const_iterator it = v.begin(); it != v.end(); ++it)
+        s << *it;
+    return s;
+}
+
+template <typename T>
+QDataStream &operator>>(QDataStream &in, QSet<T> &set)
+{
+    set.clear();
+    quint32 c;
+    in >> c;
+    for (quint32 i = 0; i < c; ++i) {
+        T t;
+        in >> t;
+        set << t;
+        if (in.atEnd())
+            break;
+    }
+    return in;
+}
+
+template <typename T>
+QDataStream& operator<<(QDataStream &out, const QSet<T> &set)
+{
+    out << quint32(set.size());
+    typename QSet<T>::const_iterator i = set.constBegin();
+    while (i != set.constEnd()) {
+        out << *i;
+        ++i;
+    }
+    return out;
+}
+
+template <class Key, class T>
+ QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash)
+{
+    QDataStream::Status oldStatus = in.status();
+    in.resetStatus();
+    hash.clear();
+
+    quint32 n;
+    in >> n;
+
+    for (quint32 i = 0; i < n; ++i) {
+        if (in.status() != QDataStream::Ok)
+            break;
+
+        Key k;
+        T t;
+        in >> k >> t;
+        hash.insertMulti(k, t);
+    }
+
+    if (in.status() != QDataStream::Ok)
+        hash.clear();
+    if (oldStatus != QDataStream::Ok)
+        in.setStatus(oldStatus);
+    return in;
+}
+
+template <class Key, class T>
+ QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash)
+{
+    out << quint32(hash.size());
+    typename QHash<Key, T>::ConstIterator it = hash.end();
+    typename QHash<Key, T>::ConstIterator begin = hash.begin();
+    while (it != begin) {
+        --it;
+        out << it.key() << it.value();
+    }
+    return out;
+}
+
+
+
+
+template <class aKey, class aT>
+ QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map)
+
+{
+    QDataStream::Status oldStatus = in.status();
+    in.resetStatus();
+    map.clear();
+
+    quint32 n;
+    in >> n;
+
+    map.detach();
+    map.setInsertInOrder(true);
+    for (quint32 i = 0; i < n; ++i) {
+        if (in.status() != QDataStream::Ok)
+            break;
+
+        aKey key;
+        aT value;
+        in >> key >> value;
+        map.insertMulti(key, value);
+    }
+    map.setInsertInOrder(false);
+    if (in.status() != QDataStream::Ok)
+        map.clear();
+    if (oldStatus != QDataStream::Ok)
+        in.setStatus(oldStatus);
+    return in;
+}
+
+template <class Key, class T>
+ QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map)
+{
+    out << quint32(map.size());
+    typename QMap<Key, T>::ConstIterator it = map.end();
+    typename QMap<Key, T>::ConstIterator begin = map.begin();
+    while (it != begin) {
+        --it;
+        out << it.key() << it.value();
+    }
+    return out;
+}
+
+
+
+
+
+
+# 47 "/usr/include/qt4/QtCore/qstringlist.h" 2
+
+# 1 "/usr/include/qt4/QtCore/qregexp.h" 1
+# 52 "/usr/include/qt4/QtCore/qregexp.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+struct QRegExpPrivate;
+class QStringList;
+
+class QRegExp
+{
+public:
+    enum PatternSyntax {
+        RegExp,
+        Wildcard,
+        FixedString,
+        RegExp2,
+        WildcardUnix,
+        W3CXmlSchema11 };
+    enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };
+
+    QRegExp();
+    explicit QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive,
+       PatternSyntax syntax = RegExp);
+    QRegExp(const QRegExp &rx);
+    ~QRegExp();
+    QRegExp &operator=(const QRegExp &rx);
+
+    bool operator==(const QRegExp &rx) const;
+    inline bool operator!=(const QRegExp &rx) const { return !operator==(rx); }
+
+    bool isEmpty() const;
+    bool isValid() const;
+    QString pattern() const;
+    void setPattern(const QString &pattern);
+    Qt::CaseSensitivity caseSensitivity() const;
+    void setCaseSensitivity(Qt::CaseSensitivity cs);
+
+
+
+
+
+    PatternSyntax patternSyntax() const;
+    void setPatternSyntax(PatternSyntax syntax);
+
+
+
+
+
+
+    bool isMinimal() const;
+    void setMinimal(bool minimal);
+
+
+
+
+    bool exactMatch(const QString &str) const;
+
+    int indexIn(const QString &str, int offset = 0, CaretMode caretMode = CaretAtZero) const;
+    int lastIndexIn(const QString &str, int offset = -1, CaretMode caretMode = CaretAtZero) const;
+# 120 "/usr/include/qt4/QtCore/qregexp.h"
+    int matchedLength() const;
+
+
+    int numCaptures() const;
+
+    int captureCount() const;
+    QStringList capturedTexts() const;
+    QStringList capturedTexts();
+    QString cap(int nth = 0) const;
+    QString cap(int nth = 0);
+    int pos(int nth = 0) const;
+    int pos(int nth = 0);
+    QString errorString() const;
+    QString errorString();
+
+
+    static QString escape(const QString &str);
+# 147 "/usr/include/qt4/QtCore/qregexp.h"
+private:
+    QRegExpPrivate *priv;
+};
+
+template <> class QTypeInfo<QRegExp > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRegExp)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRegExp"; } };
+
+
+ QDataStream &operator<<(QDataStream &out, const QRegExp &regExp);
+ QDataStream &operator>>(QDataStream &in, QRegExp &regExp);
+
+
+
+
+
+# 49 "/usr/include/qt4/QtCore/qstringlist.h" 2
+
+# 1 "/usr/include/qt4/QtCore/qstringmatcher.h" 1
+# 47 "/usr/include/qt4/QtCore/qstringmatcher.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QStringMatcherPrivate;
+
+class QStringMatcher
+{
+public:
+    QStringMatcher();
+    QStringMatcher(const QString &pattern,
+                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QStringMatcher(const QChar *uc, int len,
+                   Qt::CaseSensitivity cs = Qt::CaseSensitive);
+    QStringMatcher(const QStringMatcher &other);
+    ~QStringMatcher();
+
+    QStringMatcher &operator=(const QStringMatcher &other);
+
+    void setPattern(const QString &pattern);
+    void setCaseSensitivity(Qt::CaseSensitivity cs);
+
+    int indexIn(const QString &str, int from = 0) const;
+    int indexIn(const QChar *str, int length, int from = 0) const;
+    QString pattern() const;
+    inline Qt::CaseSensitivity caseSensitivity() const { return q_cs; }
+
+private:
+    QStringMatcherPrivate *d_ptr;
+    QString q_pattern;
+    Qt::CaseSensitivity q_cs;
+
+
+
+
+
+    struct Data {
+        uchar q_skiptable[256];
+        const QChar *uc;
+        int len;
+    };
+    union {
+        uint q_data[256];
+        Data p;
+    };
+
+
+
+};
+
+
+
+
+# 51 "/usr/include/qt4/QtCore/qstringlist.h" 2
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QRegExp;
+
+typedef QListIterator<QString> QStringListIterator;
+typedef QMutableListIterator<QString> QMutableStringListIterator;
+
+class QStringList : public QList<QString>
+{
+public:
+    inline QStringList() { }
+    inline explicit QStringList(const QString &i) { append(i); }
+    inline QStringList(const QStringList &l) : QList<QString>(l) { }
+    inline QStringList(const QList<QString> &l) : QList<QString>(l) { }
+
+    inline void sort();
+    inline int removeDuplicates();
+
+    inline QString join(const QString &sep) const;
+
+    inline QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+    inline QBool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const;
+
+    inline QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive);
+
+    inline QStringList operator+(const QStringList &other) const
+    { QStringList n = *this; n += other; return n; }
+    inline QStringList &operator<<(const QString &str)
+    { append(str); return *this; }
+    inline QStringList &operator<<(const QStringList &l)
+    { *this += l; return *this; }
+
+
+    inline QStringList filter(const QRegExp &rx) const;
+    inline QStringList &replaceInStrings(const QRegExp &rx, const QString &after);
+    inline int indexOf(const QRegExp &rx, int from = 0) const;
+    inline int lastIndexOf(const QRegExp &rx, int from = -1) const;
+    inline int indexOf(QRegExp &rx, int from = 0) const;
+    inline int lastIndexOf(QRegExp &rx, int from = -1) const;
+
+
+    using QList<QString>::indexOf;
+    using QList<QString>::lastIndexOf;
+# 126 "/usr/include/qt4/QtCore/qstringlist.h"
+};
+
+namespace QtPrivate {
+    void QStringList_sort(QStringList *that);
+    int QStringList_removeDuplicates(QStringList *that);
+    QString QStringList_join(const QStringList *that, const QString &sep);
+    QStringList QStringList_filter(const QStringList *that, const QString &str,
+                                               Qt::CaseSensitivity cs);
+
+    QBool QStringList_contains(const QStringList *that, const QString &str, Qt::CaseSensitivity cs);
+    void QStringList_replaceInStrings(QStringList *that, const QString &before, const QString &after,
+                                      Qt::CaseSensitivity cs);
+
+
+    void QStringList_replaceInStrings(QStringList *that, const QRegExp &rx, const QString &after);
+    QStringList QStringList_filter(const QStringList *that, const QRegExp &re);
+    int QStringList_indexOf(const QStringList *that, const QRegExp &rx, int from);
+    int QStringList_lastIndexOf(const QStringList *that, const QRegExp &rx, int from);
+    int QStringList_indexOf(const QStringList *that, QRegExp &rx, int from);
+    int QStringList_lastIndexOf(const QStringList *that, QRegExp &rx, int from);
+
+}
+
+inline void QStringList::sort()
+{
+    QtPrivate::QStringList_sort(this);
+}
+
+inline int QStringList::removeDuplicates()
+{
+    return QtPrivate::QStringList_removeDuplicates(this);
+}
+
+inline QString QStringList::join(const QString &sep) const
+{
+    return QtPrivate::QStringList_join(this, sep);
+}
+
+inline QStringList QStringList::filter(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return QtPrivate::QStringList_filter(this, str, cs);
+}
+
+inline QBool QStringList::contains(const QString &str, Qt::CaseSensitivity cs) const
+{
+    return QtPrivate::QStringList_contains(this, str, cs);
+}
+
+inline QStringList &QStringList::replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs)
+{
+    QtPrivate::QStringList_replaceInStrings(this, before, after, cs);
+    return *this;
+}
+
+
+inline QStringList &QStringList::replaceInStrings(const QRegExp &rx, const QString &after)
+{
+    QtPrivate::QStringList_replaceInStrings(this, rx, after);
+    return *this;
+}
+
+inline QStringList QStringList::filter(const QRegExp &rx) const
+{
+    return QtPrivate::QStringList_filter(this, rx);
+}
+
+inline int QStringList::indexOf(const QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_indexOf(this, rx, from);
+}
+
+inline int QStringList::lastIndexOf(const QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
+}
+
+inline int QStringList::indexOf(QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_indexOf(this, rx, from);
+}
+
+inline int QStringList::lastIndexOf(QRegExp &rx, int from) const
+{
+    return QtPrivate::QStringList_lastIndexOf(this, rx, from);
+}
+# 245 "/usr/include/qt4/QtCore/qstringlist.h"
+inline QDataStream &operator>>(QDataStream &in, QStringList &list)
+{
+    return operator>>(in, static_cast<QList<QString> &>(list));
+}
+inline QDataStream &operator<<(QDataStream &out, const QStringList &list)
+{
+    return operator<<(out, static_cast<const QList<QString> &>(list));
+}
+
+
+
+
+
+# 48 "/usr/include/qt4/QtGui/qcolor.h" 2
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QColor;
+class QColormap;
+class QVariant;
+
+
+ QDebug operator<<(QDebug, const QColor &);
+
+
+ QDataStream &operator<<(QDataStream &, const QColor &);
+ QDataStream &operator>>(QDataStream &, QColor &);
+
+
+class QColor
+{
+public:
+    enum Spec { Invalid, Rgb, Hsv, Cmyk, Hsl };
+
+    QColor();
+    QColor(Qt::GlobalColor color);
+    QColor(int r, int g, int b, int a = 255);
+    QColor(QRgb rgb);
+    QColor(const QString& name);
+    QColor(const char *name);
+    QColor(const QColor &color);
+    QColor(Spec spec);
+
+    bool isValid() const;
+
+    QString name() const;
+    void setNamedColor(const QString& name);
+
+    static QStringList colorNames();
+
+    inline Spec spec() const
+    { return cspec; }
+
+    int alpha() const;
+    void setAlpha(int alpha);
+
+    qreal alphaF() const;
+    void setAlphaF(qreal alpha);
+
+    int red() const;
+    int green() const;
+    int blue() const;
+    void setRed(int red);
+    void setGreen(int green);
+    void setBlue(int blue);
+
+    qreal redF() const;
+    qreal greenF() const;
+    qreal blueF() const;
+    void setRedF(qreal red);
+    void setGreenF(qreal green);
+    void setBlueF(qreal blue);
+
+    void getRgb(int *r, int *g, int *b, int *a = 0) const;
+    void setRgb(int r, int g, int b, int a = 255);
+
+    void getRgbF(qreal *r, qreal *g, qreal *b, qreal *a = 0) const;
+    void setRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);
+
+    QRgb rgba() const;
+    void setRgba(QRgb rgba);
+
+    QRgb rgb() const;
+    void setRgb(QRgb rgb);
+
+    int hue() const;
+    int saturation() const;
+    int hsvHue() const;
+    int hsvSaturation() const;
+    int value() const;
+
+    qreal hueF() const;
+    qreal saturationF() const;
+    qreal hsvHueF() const;
+    qreal hsvSaturationF() const;
+    qreal valueF() const;
+
+    void getHsv(int *h, int *s, int *v, int *a = 0) const;
+    void setHsv(int h, int s, int v, int a = 255);
+
+    void getHsvF(qreal *h, qreal *s, qreal *v, qreal *a = 0) const;
+    void setHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
+
+    int cyan() const;
+    int magenta() const;
+    int yellow() const;
+    int black() const;
+
+    qreal cyanF() const;
+    qreal magentaF() const;
+    qreal yellowF() const;
+    qreal blackF() const;
+
+    void getCmyk(int *c, int *m, int *y, int *k, int *a = 0);
+    void setCmyk(int c, int m, int y, int k, int a = 255);
+
+    void getCmykF(qreal *c, qreal *m, qreal *y, qreal *k, qreal *a = 0);
+    void setCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);
+
+    int hslHue() const;
+    int hslSaturation() const;
+    int lightness() const;
+
+    qreal hslHueF() const;
+    qreal hslSaturationF() const;
+    qreal lightnessF() const;
+
+    void getHsl(int *h, int *s, int *l, int *a = 0) const;
+    void setHsl(int h, int s, int l, int a = 255);
+
+    void getHslF(qreal *h, qreal *s, qreal *l, qreal *a = 0) const;
+    void setHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
+
+    QColor toRgb() const;
+    QColor toHsv() const;
+    QColor toCmyk() const;
+    QColor toHsl() const;
+
+    QColor convertTo(Spec colorSpec) const;
+
+    static QColor fromRgb(QRgb rgb);
+    static QColor fromRgba(QRgb rgba);
+
+    static QColor fromRgb(int r, int g, int b, int a = 255);
+    static QColor fromRgbF(qreal r, qreal g, qreal b, qreal a = 1.0);
+
+    static QColor fromHsv(int h, int s, int v, int a = 255);
+    static QColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0);
+
+    static QColor fromCmyk(int c, int m, int y, int k, int a = 255);
+    static QColor fromCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0);
+
+    static QColor fromHsl(int h, int s, int l, int a = 255);
+    static QColor fromHslF(qreal h, qreal s, qreal l, qreal a = 1.0);
+
+    QColor light(int f = 150) const;
+    QColor lighter(int f = 150) const;
+    QColor dark(int f = 200) const;
+    QColor darker(int f = 200) const;
+
+    QColor &operator=(const QColor &);
+    QColor &operator=(Qt::GlobalColor color);
+
+    bool operator==(const QColor &c) const;
+    bool operator!=(const QColor &c) const;
+
+    operator QVariant() const;
+
+
+    static bool allowX11ColorNames();
+    static void setAllowX11ColorNames(bool enabled);
+# 228 "/usr/include/qt4/QtGui/qcolor.h"
+private:
+
+
+    QColor(int, int, int, Spec);
+
+
+    void invalidate();
+
+    Spec cspec;
+    union {
+        struct {
+            ushort alpha;
+            ushort red;
+            ushort green;
+            ushort blue;
+            ushort pad;
+        } argb;
+        struct {
+            ushort alpha;
+            ushort hue;
+            ushort saturation;
+            ushort value;
+            ushort pad;
+        } ahsv;
+        struct {
+            ushort alpha;
+            ushort cyan;
+            ushort magenta;
+            ushort yellow;
+            ushort black;
+        } acmyk;
+        struct {
+            ushort alpha;
+            ushort hue;
+            ushort saturation;
+            ushort lightness;
+            ushort pad;
+        } ahsl;
+        ushort array[5];
+    } ct;
+
+    friend class QColormap;
+
+    friend QDataStream &operator<<(QDataStream &, const QColor &);
+    friend QDataStream &operator>>(QDataStream &, QColor &);
+
+};
+
+inline QColor::QColor()
+{ invalidate(); }
+
+inline QColor::QColor(int r, int g, int b, int a)
+{ setRgb(r, g, b, a); }
+
+inline QColor::QColor(const char *aname)
+{ setNamedColor(QLatin1String(aname)); }
+
+inline QColor::QColor(const QString& aname)
+{ setNamedColor(aname); }
+
+inline QColor::QColor(const QColor &acolor)
+    : cspec(acolor.cspec)
+{ ct.argb = acolor.ct.argb; }
+
+inline bool QColor::isValid() const
+{ return cspec != Invalid; }
+
+inline QColor QColor::lighter(int f) const
+{ return light(f); }
+
+inline QColor QColor::darker(int f) const
+{ return dark(f); }
+
+
+
+
+# 47 "/usr/include/qt4/QtGui/qpixmap.h" 2
+
+
+# 1 "/usr/include/qt4/QtCore/qsharedpointer.h" 1
+# 47 "/usr/include/qt4/QtCore/qsharedpointer.h"
+# 1 "/usr/include/qt4/QtCore/qshareddata.h" 1
+# 48 "/usr/include/qt4/QtCore/qshareddata.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+template <class T> class QSharedDataPointer;
+
+class QSharedData
+{
+public:
+    mutable QAtomicInt ref;
+
+    inline QSharedData() : ref(0) { }
+    inline QSharedData(const QSharedData &) : ref(0) { }
+
+private:
+
+    QSharedData &operator=(const QSharedData &);
+};
+
+template <class T> class QSharedDataPointer
+{
+public:
+    typedef T Type;
+    typedef T *pointer;
+
+    inline void detach() { if (d && d->ref != 1) detach_helper(); }
+    inline T &operator*() { detach(); return *d; }
+    inline const T &operator*() const { return *d; }
+    inline T *operator->() { detach(); return d; }
+    inline const T *operator->() const { return d; }
+    inline operator T *() { detach(); return d; }
+    inline operator const T *() const { return d; }
+    inline T *data() { detach(); return d; }
+    inline const T *data() const { return d; }
+    inline const T *constData() const { return d; }
+
+    inline bool operator==(const QSharedDataPointer<T> &other) const { return d == other.d; }
+    inline bool operator!=(const QSharedDataPointer<T> &other) const { return d != other.d; }
+
+    inline QSharedDataPointer() { d = 0; }
+    inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; }
+
+    explicit QSharedDataPointer(T *data);
+    inline QSharedDataPointer(const QSharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
+    inline QSharedDataPointer<T> & operator=(const QSharedDataPointer<T> &o) {
+        if (o.d != d) {
+            if (o.d)
+                o.d->ref.ref();
+            if (d && !d->ref.deref())
+                delete d;
+            d = o.d;
+        }
+        return *this;
+    }
+    inline QSharedDataPointer &operator=(T *o) {
+        if (o != d) {
+            if (o)
+                o->ref.ref();
+            if (d && !d->ref.deref())
+                delete d;
+            d = o;
+        }
+        return *this;
+    }
+
+    inline bool operator!() const { return !d; }
+
+    inline void swap(QSharedDataPointer &other)
+    { qSwap(d, other.d); }
+
+public:
+    T *clone();
+
+private:
+    void detach_helper();
+
+    T *d;
+};
+
+template <class T> class QExplicitlySharedDataPointer
+{
+public:
+    typedef T Type;
+    typedef T *pointer;
+
+    inline T &operator*() const { return *d; }
+    inline T *operator->() { return d; }
+    inline T *operator->() const { return d; }
+    inline T *data() const { return d; }
+    inline const T *constData() const { return d; }
+
+    inline void detach() { if (d && d->ref != 1) detach_helper(); }
+
+    inline void reset()
+    {
+        if(d && !d->ref.deref())
+            delete d;
+
+        d = 0;
+    }
+
+    inline operator bool () const { return d != 0; }
+
+    inline bool operator==(const QExplicitlySharedDataPointer<T> &other) const { return d == other.d; }
+    inline bool operator!=(const QExplicitlySharedDataPointer<T> &other) const { return d != other.d; }
+    inline bool operator==(const T *ptr) const { return d == ptr; }
+    inline bool operator!=(const T *ptr) const { return d != ptr; }
+
+    inline QExplicitlySharedDataPointer() { d = 0; }
+    inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; }
+
+    explicit QExplicitlySharedDataPointer(T *data);
+    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); }
+
+
+    template<class X>
+    inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o) : d(static_cast<T *>(o.data()))
+    {
+        if(d)
+            d->ref.ref();
+    }
+
+
+    inline QExplicitlySharedDataPointer<T> & operator=(const QExplicitlySharedDataPointer<T> &o) {
+        if (o.d != d) {
+            if (o.d)
+                o.d->ref.ref();
+            if (d && !d->ref.deref())
+                delete d;
+            d = o.d;
+        }
+        return *this;
+    }
+    inline QExplicitlySharedDataPointer &operator=(T *o) {
+        if (o != d) {
+            if (o)
+                o->ref.ref();
+            if (d && !d->ref.deref())
+                delete d;
+            d = o;
+        }
+        return *this;
+    }
+
+    inline bool operator!() const { return !d; }
+
+    inline void swap(QExplicitlySharedDataPointer &other)
+    { qSwap(d, other.d); }
+
+public:
+    T *clone();
+
+private:
+    void detach_helper();
+
+    T *d;
+};
+
+template <class T>
+inline QSharedDataPointer<T>::QSharedDataPointer(T *adata) : d(adata)
+{ if (d) d->ref.ref(); }
+
+template <class T>
+inline T *QSharedDataPointer<T>::clone()
+{
+    return new T(*d);
+}
+
+template <class T>
+ void QSharedDataPointer<T>::detach_helper()
+{
+    T *x = clone();
+    x->ref.ref();
+    if (!d->ref.deref())
+        delete d;
+    d = x;
+}
+
+template <class T>
+inline T *QExplicitlySharedDataPointer<T>::clone()
+{
+    return new T(*d);
+}
+
+template <class T>
+ void QExplicitlySharedDataPointer<T>::detach_helper()
+{
+    T *x = clone();
+    x->ref.ref();
+    if (!d->ref.deref())
+        delete d;
+    d = x;
+}
+
+template <class T>
+inline QExplicitlySharedDataPointer<T>::QExplicitlySharedDataPointer(T *adata) : d(adata)
+{ if (d) d->ref.ref(); }
+
+template <class T>
+inline void qSwap(QSharedDataPointer<T> &p1, QSharedDataPointer<T> &p2)
+{ p1.swap(p2); }
+
+template <class T>
+inline void qSwap(QExplicitlySharedDataPointer<T> &p1, QExplicitlySharedDataPointer<T> &p2)
+{ p1.swap(p2); }
+
+
+
+
+# 48 "/usr/include/qt4/QtCore/qsharedpointer.h" 2
+
+
+
+
+# 1 "/usr/include/qt4/QtCore/qsharedpointer_impl.h" 1
+# 55 "/usr/include/qt4/QtCore/qsharedpointer_impl.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+# 70 "/usr/include/qt4/QtCore/qsharedpointer_impl.h"
+template<typename T> inline void qt_sharedpointer_cast_check(T *) { }
+
+
+
+
+
+
+
+template <class T> class QWeakPointer;
+template <class T> class QSharedPointer;
+
+template <class X, class T>
+QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &ptr);
+template <class X, class T>
+QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &ptr);
+template <class X, class T>
+QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &ptr);
+
+
+template <class X, class T>
+QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &ptr);
+
+
+namespace QtSharedPointer {
+    template <class T> class InternalRefCount;
+    template <class T> class ExternalRefCount;
+
+    template <class X, class Y> QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);
+
+
+    void internalSafetyCheckAdd2(const void *, const volatile void *);
+    void internalSafetyCheckRemove2(const void *);
+
+    template <class T, typename Klass, typename RetVal>
+    inline void executeDeleter(T *t, RetVal (Klass:: *memberDeleter)())
+    { (t->*memberDeleter)(); }
+    template <class T, typename Deleter>
+    inline void executeDeleter(T *t, Deleter d)
+    { d(t); }
+    template <class T> inline void normalDeleter(T *t) { delete t; }
+
+
+
+    template <class T> struct RemovePointer;
+    template <class T> struct RemovePointer<T *> { typedef T Type; };
+    template <class T> struct RemovePointer<QSharedPointer<T> > { typedef T Type; };
+    template <class T> struct RemovePointer<QWeakPointer<T> > { typedef T Type; };
+
+
+
+
+    template <class T>
+    class Basic
+    {
+
+        typedef T *Basic:: *RestrictedBool;
+
+    public:
+        typedef T Type;
+        typedef T element_type;
+        typedef T value_type;
+        typedef value_type *pointer;
+        typedef const value_type *const_pointer;
+        typedef value_type &reference;
+        typedef const value_type &const_reference;
+        typedef ptrdiff_t difference_type;
+
+        inline T *data() const { return value; }
+        inline bool isNull() const { return !data(); }
+
+        inline operator RestrictedBool() const { return isNull() ? 0 : &Basic::value; }
+
+
+
+        inline bool operator !() const { return isNull(); }
+        inline T &operator*() const { return *data(); }
+        inline T *operator->() const { return data(); }
+
+    public:
+        inline Basic(T *ptr = 0) : value(ptr) { }
+        inline Basic(Qt::Initialization) { }
+
+
+        inline void internalConstruct(T *ptr)
+        {
+            value = ptr;
+        }
+
+
+
+
+        template <class X> friend class QWeakPointer;
+
+
+        Type *value;
+    };
+
+
+
+
+
+
+
+    struct ExternalRefCountData
+    {
+        QBasicAtomicInt weakref;
+        QBasicAtomicInt strongref;
+
+        inline ExternalRefCountData()
+        {
+            strongref = 1;
+            weakref = 1;
+        }
+        inline ExternalRefCountData(Qt::Initialization) { }
+        virtual inline ~ExternalRefCountData() { ((!(!weakref)) ? qt_assert("!weakref","/usr/include/qt4/QtCore/qsharedpointer_impl.h",184) : qt_noop()); ((!(strongref <= 0)) ? qt_assert("strongref <= 0","/usr/include/qt4/QtCore/qsharedpointer_impl.h",184) : qt_noop()); }
+
+
+
+
+        virtual inline bool destroy() { return false; }
+
+
+        static ExternalRefCountData *getAndRef(const QObject *);
+        void setQObjectShared(const QObject *, bool enable);
+
+        inline void setQObjectShared(...) { }
+    };
+
+
+
+
+    struct ExternalRefCountWithDestroyFn: public ExternalRefCountData
+    {
+        typedef void (*DestroyerFn)(ExternalRefCountData *);
+        DestroyerFn destroyer;
+
+        inline ExternalRefCountWithDestroyFn(DestroyerFn d)
+            : destroyer(d)
+        { }
+
+        inline bool destroy() { destroyer(this); return true; }
+        inline void operator delete(void *ptr) { ::operator delete(ptr); }
+    };
+
+
+
+
+
+    template <class T, typename Deleter>
+    struct ExternalRefCountWithCustomDeleter: public ExternalRefCountWithDestroyFn
+    {
+        typedef ExternalRefCountWithCustomDeleter Self;
+        typedef ExternalRefCountWithDestroyFn BaseClass;
+
+        struct CustomDeleter
+        {
+            Deleter deleter;
+            T *ptr;
+
+            inline CustomDeleter(T *p, Deleter d) : deleter(d), ptr(p) {}
+        };
+        CustomDeleter extra;
+
+
+
+
+        static inline void deleter(ExternalRefCountData *self)
+        {
+            Self *realself = static_cast<Self *>(self);
+            executeDeleter(realself->extra.ptr, realself->extra.deleter);
+
+
+            realself->extra.~CustomDeleter();
+        }
+        static void safetyCheckDeleter(ExternalRefCountData *self)
+        {
+            internalSafetyCheckRemove2(self);
+            deleter(self);
+        }
+
+        static inline Self *create(T *ptr, Deleter userDeleter)
+        {
+
+
+
+            DestroyerFn destroy = &deleter;
+
+            Self *d = static_cast<Self *>(::operator new(sizeof(Self)));
+
+
+            new (&d->extra) CustomDeleter(ptr, userDeleter);
+            new (d) BaseClass(destroy);
+
+            return d;
+        }
+    private:
+
+        ExternalRefCountWithCustomDeleter();
+        ~ExternalRefCountWithCustomDeleter();
+    };
+
+
+
+
+
+    template <class T>
+    struct ExternalRefCountWithContiguousData: public ExternalRefCountWithDestroyFn
+    {
+        typedef ExternalRefCountWithDestroyFn Parent;
+        T data;
+
+        static void deleter(ExternalRefCountData *self)
+        {
+            ExternalRefCountWithContiguousData *that =
+                    static_cast<ExternalRefCountWithContiguousData *>(self);
+            that->data.~T();
+        }
+        static void safetyCheckDeleter(ExternalRefCountData *self)
+        {
+            internalSafetyCheckRemove2(self);
+            deleter(self);
+        }
+
+        static inline ExternalRefCountData *create(T **ptr)
+        {
+
+
+
+            DestroyerFn destroy = &deleter;
+
+            ExternalRefCountWithContiguousData *d =
+                static_cast<ExternalRefCountWithContiguousData *>(::operator new(sizeof(ExternalRefCountWithContiguousData)));
+
+
+
+            new (d) Parent(destroy);
+
+            *ptr = &d->data;
+            return d;
+        }
+
+    private:
+
+        ExternalRefCountWithContiguousData();
+        ~ExternalRefCountWithContiguousData();
+    };
+
+
+
+    template <class T>
+    class ExternalRefCount: public Basic<T>
+    {
+    public:
+        typedef ExternalRefCountData Data;
+
+        inline void ref() const { d->weakref.ref(); d->strongref.ref(); }
+        inline bool deref()
+        {
+            if (!d->strongref.deref()) {
+                internalDestroy();
+            }
+            return d->weakref.deref();
+        }
+
+        inline void internalConstruct(T *ptr)
+        {
+
+
+
+            if (ptr)
+                d = new Data;
+            else
+                d = 0;
+            internalFinishConstruction(ptr);
+
+        }
+
+        template <typename Deleter>
+        inline void internalConstruct(T *ptr, Deleter deleter)
+        {
+            if (ptr)
+                d = ExternalRefCountWithCustomDeleter<T, Deleter>::create(ptr, deleter);
+            else
+                d = 0;
+            internalFinishConstruction(ptr);
+        }
+
+        inline void internalCreate()
+        {
+            T *ptr;
+            d = ExternalRefCountWithContiguousData<T>::create(&ptr);
+            Basic<T>::internalConstruct(ptr);
+        }
+
+        inline void internalFinishConstruction(T *ptr)
+        {
+            Basic<T>::internalConstruct(ptr);
+            if (ptr) d->setQObjectShared(ptr, true);
+
+
+
+        }
+
+        inline ExternalRefCount() : d(0) { }
+        inline ExternalRefCount(Qt::Initialization i) : Basic<T>(i) { }
+        inline ExternalRefCount(const ExternalRefCount<T> &other) : Basic<T>(other), d(other.d)
+        { if (d) ref(); }
+        template <class X>
+        inline ExternalRefCount(const ExternalRefCount<X> &other) : Basic<T>(other.value), d(other.d)
+        { if (d) ref(); }
+        inline ~ExternalRefCount() { if (d && !deref()) delete d; }
+
+        template <class X>
+        inline void internalCopy(const ExternalRefCount<X> &other)
+        {
+            internalSet(other.d, other.data());
+        }
+
+        inline void internalDestroy()
+        {
+            if (!d->destroy())
+                delete this->value;
+        }
+
+        inline void internalSwap(ExternalRefCount &other)
+        {
+            qSwap(d, other.d);
+            qSwap(this->value, other.value);
+        }
+
+
+
+
+        template <class X> friend class ExternalRefCount;
+        template <class X> friend class QWeakPointer;
+        template <class X, class Y> friend QSharedPointer<X> copyAndSetPointer(X * ptr, const QSharedPointer<Y> &src);
+
+
+        inline void internalSet(Data *o, T *actual)
+        {
+            if (o) {
+
+
+                register int tmp = o->strongref;
+                while (tmp > 0) {
+
+                    if (o->strongref.testAndSetRelaxed(tmp, tmp + 1))
+                        break;
+                    tmp = o->strongref;
+                }
+
+                if (tmp > 0)
+                    o->weakref.ref();
+                else
+                    o = 0;
+            }
+            if (d && !deref())
+                delete d;
+            d = o;
+            this->value = d && d->strongref ? actual : 0;
+        }
+
+        Data *d;
+
+    private:
+        template<class X> ExternalRefCount(const InternalRefCount<X> &);
+    };
+}
+
+template <class T>
+class QSharedPointer: public QtSharedPointer::ExternalRefCount<T>
+{
+    typedef typename QtSharedPointer::ExternalRefCount<T> BaseClass;
+public:
+    inline QSharedPointer() { }
+
+
+    inline explicit QSharedPointer(T *ptr) : BaseClass(Qt::Uninitialized)
+    { BaseClass::internalConstruct(ptr); }
+
+    template <typename Deleter>
+    inline QSharedPointer(T *ptr, Deleter d) { BaseClass::internalConstruct(ptr, d); }
+
+    inline QSharedPointer(const QSharedPointer<T> &other) : BaseClass(other) { }
+    inline QSharedPointer<T> &operator=(const QSharedPointer<T> &other)
+    {
+        BaseClass::internalCopy(other);
+        return *this;
+    }
+
+    template <class X>
+    inline QSharedPointer(const QSharedPointer<X> &other) : BaseClass(other)
+    { }
+
+    template <class X>
+    inline QSharedPointer<T> &operator=(const QSharedPointer<X> &other)
+    {
+        qt_sharedpointer_cast_check<T>(static_cast<X *>(0));
+        BaseClass::internalCopy(other);
+        return *this;
+    }
+
+    template <class X>
+    inline QSharedPointer(const QWeakPointer<X> &other) : BaseClass(Qt::Uninitialized)
+    { this->d = 0; *this = other; }
+
+    template <class X>
+    inline QSharedPointer<T> &operator=(const QWeakPointer<X> &other)
+    { BaseClass::internalSet(other.d, other.value); return *this; }
+
+    inline void swap(QSharedPointer &other)
+    { QSharedPointer<T>::internalSwap(other); }
+
+    template <class X>
+    QSharedPointer<X> staticCast() const
+    {
+        return qSharedPointerCast<X, T>(*this);
+    }
+
+    template <class X>
+    QSharedPointer<X> dynamicCast() const
+    {
+        return qSharedPointerDynamicCast<X, T>(*this);
+    }
+
+    template <class X>
+    QSharedPointer<X> constCast() const
+    {
+        return qSharedPointerConstCast<X, T>(*this);
+    }
+
+
+    template <class X>
+    QSharedPointer<X> objectCast() const
+    {
+        return qSharedPointerObjectCast<X, T>(*this);
+    }
+
+
+    inline void clear() { *this = QSharedPointer<T>(); }
+
+    QWeakPointer<T> toWeakRef() const;
+
+public:
+    inline explicit QSharedPointer(Qt::Initialization i) : BaseClass(i) {}
+
+public:
+    static inline QSharedPointer<T> create()
+    {
+        QSharedPointer<T> result(Qt::Uninitialized);
+        result.internalCreate();
+
+
+        new (result.data()) T();
+        result.internalFinishConstruction(result.data());
+        return result;
+    }
+};
+
+template <class T>
+class QWeakPointer
+{
+
+    typedef T *QWeakPointer:: *RestrictedBool;
+
+    typedef QtSharedPointer::ExternalRefCountData Data;
+
+public:
+    typedef T element_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef ptrdiff_t difference_type;
+
+    inline bool isNull() const { return d == 0 || d->strongref == 0 || value == 0; }
+
+    inline operator RestrictedBool() const { return isNull() ? 0 : &QWeakPointer::value; }
+
+
+
+    inline bool operator !() const { return isNull(); }
+    inline T *data() const { return d == 0 || d->strongref == 0 ? 0 : value; }
+
+    inline QWeakPointer() : d(0), value(0) { }
+    inline ~QWeakPointer() { if (d && !d->weakref.deref()) delete d; }
+
+
+
+    template <class X>
+    inline QWeakPointer(X *ptr) : d(ptr ? d->getAndRef(ptr) : 0), value(ptr)
+    { }
+
+    template <class X>
+    inline QWeakPointer &operator=(X *ptr)
+    { return *this = QWeakPointer(ptr); }
+
+    inline QWeakPointer(const QWeakPointer<T> &o) : d(o.d), value(o.value)
+    { if (d) d->weakref.ref(); }
+    inline QWeakPointer<T> &operator=(const QWeakPointer<T> &o)
+    {
+        internalSet(o.d, o.value);
+        return *this;
+    }
+
+    inline QWeakPointer(const QSharedPointer<T> &o) : d(o.d), value(o.data())
+    { if (d) d->weakref.ref();}
+    inline QWeakPointer<T> &operator=(const QSharedPointer<T> &o)
+    {
+        internalSet(o.d, o.value);
+        return *this;
+    }
+
+    template <class X>
+    inline QWeakPointer(const QWeakPointer<X> &o) : d(0), value(0)
+    { *this = o; }
+
+    template <class X>
+    inline QWeakPointer<T> &operator=(const QWeakPointer<X> &o)
+    {
+
+
+        *this = o.toStrongRef();
+        return *this;
+    }
+
+    template <class X>
+    inline bool operator==(const QWeakPointer<X> &o) const
+    { return d == o.d && value == static_cast<const T *>(o.value); }
+
+    template <class X>
+    inline bool operator!=(const QWeakPointer<X> &o) const
+    { return !(*this == o); }
+
+    template <class X>
+    inline QWeakPointer(const QSharedPointer<X> &o) : d(0), value(0)
+    { *this = o; }
+
+    template <class X>
+    inline QWeakPointer<T> &operator=(const QSharedPointer<X> &o)
+    {
+        qt_sharedpointer_cast_check<T>(static_cast<X *>(0));
+        internalSet(o.d, o.data());
+        return *this;
+    }
+
+    template <class X>
+    inline bool operator==(const QSharedPointer<X> &o) const
+    { return d == o.d; }
+
+    template <class X>
+    inline bool operator!=(const QSharedPointer<X> &o) const
+    { return !(*this == o); }
+
+    inline void clear() { *this = QWeakPointer<T>(); }
+
+    inline QSharedPointer<T> toStrongRef() const { return QSharedPointer<T>(*this); }
+
+
+
+
+
+private:
+
+
+
+
+    template <class X> friend class QSharedPointer;
+
+
+    inline void internalSet(Data *o, T *actual)
+    {
+        if (d == o) return;
+        if (o)
+            o->weakref.ref();
+        if (d && !d->weakref.deref())
+            delete d;
+        d = o;
+        value = actual;
+    }
+
+    Data *d;
+    T *value;
+};
+
+template <class T, class X>
+bool operator==(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1.data() == ptr2.data();
+}
+template <class T, class X>
+bool operator!=(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1.data() != ptr2.data();
+}
+
+template <class T, class X>
+bool operator==(const QSharedPointer<T> &ptr1, const X *ptr2)
+{
+    return ptr1.data() == ptr2;
+}
+template <class T, class X>
+bool operator==(const T *ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1 == ptr2.data();
+}
+
+template <class T, class X>
+bool operator!=(const QSharedPointer<T> &ptr1, const X *ptr2)
+{
+    return !(ptr1 == ptr2);
+}
+template <class T, class X>
+bool operator!=(const T *ptr1, const QSharedPointer<X> &ptr2)
+{
+    return !(ptr2 == ptr1);
+}
+
+template <class T, class X>
+bool operator==(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
+{
+    return ptr2 == ptr1;
+}
+template <class T, class X>
+bool operator!=(const QSharedPointer<T> &ptr1, const QWeakPointer<X> &ptr2)
+{
+    return ptr2 != ptr1;
+}
+
+template <class T, class X>
+inline typename T::difference_type operator-(const QSharedPointer<T> &ptr1, const QSharedPointer<X> &ptr2)
+{
+    return ptr1.data() - ptr2.data();
+}
+
+template <class T>
+inline QWeakPointer<T> QSharedPointer<T>::toWeakRef() const
+{
+    return QWeakPointer<T>(*this);
+}
+
+template <class T>
+inline void qSwap(QSharedPointer<T> &p1, QSharedPointer<T> &p2)
+{
+    p1.swap(p2);
+}
+
+namespace QtSharedPointer {
+
+    template <class X, class T>
+    inline QSharedPointer<X> copyAndSetPointer(X *ptr, const QSharedPointer<T> &src)
+    {
+        QSharedPointer<X> result;
+        result.internalSet(src.d, ptr);
+        return result;
+    }
+}
+
+
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = static_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerCast<X, T>(src.toStrongRef());
+}
+
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerDynamicCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = dynamic_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerDynamicCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerDynamicCast<X, T>(src.toStrongRef());
+}
+
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerConstCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = const_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerConstCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerConstCast<X, T>(src.toStrongRef());
+}
+
+template <class X, class T>
+inline
+QWeakPointer<X> qWeakPointerCast(const QSharedPointer<T> &src)
+{
+    return qSharedPointerCast<X, T>(src).toWeakRef();
+}
+
+
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerObjectCast(const QSharedPointer<T> &src)
+{
+    register X *ptr = qobject_cast<X *>(src.data());
+    return QtSharedPointer::copyAndSetPointer(ptr, src);
+}
+template <class X, class T>
+inline QSharedPointer<X> qSharedPointerObjectCast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerObjectCast<X>(src.toStrongRef());
+}
+
+template <class X, class T>
+inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
+qobject_cast(const QSharedPointer<T> &src)
+{
+    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
+}
+template <class X, class T>
+inline QSharedPointer<typename QtSharedPointer::RemovePointer<X>::Type>
+qobject_cast(const QWeakPointer<T> &src)
+{
+    return qSharedPointerObjectCast<typename QtSharedPointer::RemovePointer<X>::Type, T>(src);
+}
+
+
+
+
+
+
+# 53 "/usr/include/qt4/QtCore/qsharedpointer.h" 2
+# 50 "/usr/include/qt4/QtGui/qpixmap.h" 2
+# 1 "/usr/include/qt4/QtGui/qimage.h" 1
+# 45 "/usr/include/qt4/QtGui/qimage.h"
+# 1 "/usr/include/qt4/QtGui/qtransform.h" 1
+# 44 "/usr/include/qt4/QtGui/qtransform.h"
+# 1 "/usr/include/qt4/QtGui/qmatrix.h" 1
+# 45 "/usr/include/qt4/QtGui/qmatrix.h"
+# 1 "/usr/include/qt4/QtGui/qpolygon.h" 1
+# 45 "/usr/include/qt4/QtGui/qpolygon.h"
+# 1 "/usr/include/qt4/QtCore/qvector.h" 1
+# 52 "/usr/include/qt4/QtCore/qvector.h"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 1 3
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 3
+       
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_construct.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_construct.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+  template<typename _T1, typename _T2>
+    inline void
+
+
+
+
+    _Construct(_T1* __p, const _T2& __value)
+
+    {
+
+
+      ::new(static_cast<void*>(__p)) _T1((__value));
+    }
+
+
+
+
+  template<typename _Tp>
+    inline void
+    _Destroy(_Tp* __pointer)
+    { __pointer->~_Tp(); }
+
+  template<bool>
+    struct _Destroy_aux
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator __first, _ForwardIterator __last)
+ {
+   for (; __first != __last; ++__first)
+     std::_Destroy(&*__first);
+ }
+    };
+
+  template<>
+    struct _Destroy_aux<true>
+    {
+      template<typename _ForwardIterator>
+        static void
+        __destroy(_ForwardIterator, _ForwardIterator) { }
+    };
+
+
+
+
+
+
+  template<typename _ForwardIterator>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+                       _Value_type;
+      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
+ __destroy(__first, __last);
+    }
+
+
+
+
+
+
+
+  template <typename _Tp> class allocator;
+
+  template<typename _ForwardIterator, typename _Allocator>
+    void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      _Allocator& __alloc)
+    {
+      for (; __first != __last; ++__first)
+ __alloc.destroy(&*__first);
+    }
+
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
+      allocator<_Tp>&)
+    {
+      _Destroy(__first, __last);
+    }
+
+}
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<bool>
+    struct __uninitialized_copy
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        uninitialized_copy(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result)
+        {
+   _ForwardIterator __cur = __result;
+   try
+     {
+       for (; __first != __last; ++__first, ++__cur)
+  std::_Construct(&*__cur, *__first);
+       return __cur;
+     }
+   catch(...)
+     {
+       std::_Destroy(__result, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_copy<true>
+    {
+      template<typename _InputIterator, typename _ForwardIterator>
+        static _ForwardIterator
+        uninitialized_copy(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result)
+        { return std::copy(__first, __last, __result); }
+    };
+# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+    inline _ForwardIterator
+    uninitialized_copy(_InputIterator __first, _InputIterator __last,
+         _ForwardIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType2;
+
+      return std::__uninitialized_copy<(__is_pod(_ValueType1)
+     && __is_pod(_ValueType2))>::
+ uninitialized_copy(__first, __last, __result);
+    }
+
+
+  template<bool>
+    struct __uninitialized_fill
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        uninitialized_fill(_ForwardIterator __first,
+      _ForwardIterator __last, const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __cur != __last; ++__cur)
+  std::_Construct(&*__cur, __x);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_fill<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        uninitialized_fill(_ForwardIterator __first,
+      _ForwardIterator __last, const _Tp& __x)
+        { std::fill(__first, __last, __x); }
+    };
+# 161 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
+         const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      std::__uninitialized_fill<__is_pod(_ValueType)>::
+ uninitialized_fill(__first, __last, __x);
+    }
+
+
+  template<bool>
+    struct __uninitialized_construct_range_dispatch
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __ucr(_ForwardIterator __first, _ForwardIterator __last,
+       _Tp& __value)
+        {
+   if(__first == __last)
+     return;
+
+   _ForwardIterator __cur = __first;
+   try
+     {
+       std::_Construct(&*__first, (__value));
+       _ForwardIterator __prev = __cur;
+       ++__cur;
+       for(; __cur != __last; ++__cur, ++__prev)
+  std::_Construct(&*__cur, (*__prev));
+       __value = (*__prev);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_construct_range_dispatch<true>
+    {
+      template<typename _ForwardIterator, typename _Tp>
+        static void
+        __ucr(_ForwardIterator, _ForwardIterator, _Tp&) { }
+    };
+# 221 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    inline void
+    __uninitialized_construct_range(_ForwardIterator __first,
+        _ForwardIterator __last,
+        _Tp& __value)
+    {
+      typedef typename std::iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      std::__uninitialized_construct_range_dispatch<
+        __has_trivial_constructor(_ValueType)>::
+   __ucr(__first, __last, __value);
+    }
+
+
+  template<bool>
+    struct __uninitialized_fill_n
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static void
+        uninitialized_fill_n(_ForwardIterator __first, _Size __n,
+        const _Tp& __x)
+        {
+   _ForwardIterator __cur = __first;
+   try
+     {
+       for (; __n > 0; --__n, ++__cur)
+  std::_Construct(&*__cur, __x);
+     }
+   catch(...)
+     {
+       std::_Destroy(__first, __cur);
+       throw;
+     }
+ }
+    };
+
+  template<>
+    struct __uninitialized_fill_n<true>
+    {
+      template<typename _ForwardIterator, typename _Size, typename _Tp>
+        static void
+        uninitialized_fill_n(_ForwardIterator __first, _Size __n,
+        const _Tp& __x)
+        { std::fill_n(__first, __n, __x); }
+    };
+# 277 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
+  template<typename _ForwardIterator, typename _Size, typename _Tp>
+    inline void
+    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+      std::__uninitialized_fill_n<__is_pod(_ValueType)>::
+ uninitialized_fill_n(__first, __n, __x);
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __result;
+      try
+ {
+   for (; __first != __last; ++__first, ++__cur)
+     __alloc.construct(&*__cur, *__first);
+   return __cur;
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
+    inline _ForwardIterator
+    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, allocator<_Tp>&)
+    { return std::uninitialized_copy(__first, __last, __result); }
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
+      _ForwardIterator __result, _Allocator& __alloc)
+    {
+      return std::__uninitialized_copy_a((__first),
+      (__last),
+      __result, __alloc);
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
+    void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   for (; __cur != __last; ++__cur)
+     __alloc.construct(&*__cur, __x);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
+    inline void
+    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
+      const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill(__first, __last, __x); }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Allocator>
+    void
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, _Allocator& __alloc)
+    {
+      _ForwardIterator __cur = __first;
+      try
+ {
+   for (; __n > 0; --__n, ++__cur)
+     __alloc.construct(&*__cur, __x);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first, __cur, __alloc);
+   throw;
+ }
+    }
+
+  template<typename _ForwardIterator, typename _Size, typename _Tp,
+    typename _Tp2>
+    inline void
+    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
+        const _Tp& __x, allocator<_Tp2>&)
+    { std::uninitialized_fill_n(__first, __n, __x); }
+# 391 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_copy_move(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _ForwardIterator, typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_move_copy(_InputIterator1 __first1,
+         _InputIterator1 __last1,
+         _InputIterator2 __first2,
+         _InputIterator2 __last2,
+         _ForwardIterator __result,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
+          __result,
+          __alloc);
+      try
+ {
+   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
+    typename _Allocator>
+    inline _ForwardIterator
+    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
+         const _Tp& __x, _InputIterator __first,
+         _InputIterator __last, _Allocator& __alloc)
+    {
+      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
+      try
+ {
+   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__result, __mid, __alloc);
+   throw;
+ }
+    }
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
+    typename _Allocator>
+    inline void
+    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
+         _ForwardIterator __first2,
+         _ForwardIterator __last2, const _Tp& __x,
+         _Allocator& __alloc)
+    {
+      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
+           __first2,
+           __alloc);
+      try
+ {
+   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
+ }
+      catch(...)
+ {
+   std::_Destroy(__first2, __mid2, __alloc);
+   throw;
+ }
+    }
+# 537 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_uninitialized.h" 3
+}
+# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 1 3
+# 65 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  template<typename _Tp, typename _Alloc>
+    struct _Vector_base
+    {
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+
+      struct _Vector_impl
+      : public _Tp_alloc_type
+      {
+ typename _Tp_alloc_type::pointer _M_start;
+ typename _Tp_alloc_type::pointer _M_finish;
+ typename _Tp_alloc_type::pointer _M_end_of_storage;
+
+ _Vector_impl()
+ : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0)
+ { }
+
+ _Vector_impl(_Tp_alloc_type const& __a)
+ : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0)
+ { }
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Tp_alloc_type&
+      _M_get_Tp_allocator()
+      { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); }
+
+      const _Tp_alloc_type&
+      _M_get_Tp_allocator() const
+      { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Tp_allocator()); }
+
+      _Vector_base()
+      : _M_impl() { }
+
+      _Vector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+
+      _Vector_base(size_t __n, const allocator_type& __a)
+      : _M_impl(__a)
+      {
+ this->_M_impl._M_start = this->_M_allocate(__n);
+ this->_M_impl._M_finish = this->_M_impl._M_start;
+ this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+      }
+# 131 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      ~_Vector_base()
+      { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
+        - this->_M_impl._M_start); }
+
+    public:
+      _Vector_impl _M_impl;
+
+      typename _Tp_alloc_type::pointer
+      _M_allocate(size_t __n)
+      { return __n != 0 ? _M_impl.allocate(__n) : 0; }
+
+      void
+      _M_deallocate(typename _Tp_alloc_type::pointer __p, size_t __n)
+      {
+ if (__p)
+   _M_impl.deallocate(__p, __n);
+      }
+    };
+# 169 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+    class vector : public _Vector_base<_Tp, _Alloc>
+    {
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+     
+     
+
+      typedef _Vector_base<_Tp, _Alloc> _Base;
+      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
+
+    public:
+      typedef _Tp value_type;
+      typedef typename _Tp_alloc_type::pointer pointer;
+      typedef typename _Tp_alloc_type::const_pointer const_pointer;
+      typedef typename _Tp_alloc_type::reference reference;
+      typedef typename _Tp_alloc_type::const_reference const_reference;
+      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
+      const_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+    public:
+      using _Base::_M_allocate;
+      using _Base::_M_deallocate;
+      using _Base::_M_impl;
+      using _Base::_M_get_Tp_allocator;
+
+    public:
+
+
+
+
+
+      vector()
+      : _Base() { }
+
+
+
+
+
+      explicit
+      vector(const allocator_type& __a)
+      : _Base(__a) { }
+# 226 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      explicit
+      vector(size_type __n, const value_type& __value = value_type(),
+      const allocator_type& __a = allocator_type())
+      : _Base(__n, __a)
+      { _M_fill_initialize(__n, __value); }
+# 241 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      vector(const vector& __x)
+      : _Base(__x.size(), __x._M_get_Tp_allocator())
+      { this->_M_impl._M_finish =
+   std::__uninitialized_copy_a(__x.begin(), __x.end(),
+          this->_M_impl._M_start,
+          _M_get_Tp_allocator());
+      }
+# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      template<typename _InputIterator>
+        vector(_InputIterator __first, _InputIterator __last,
+        const allocator_type& __a = allocator_type())
+ : _Base(__a)
+        {
+
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_initialize_dispatch(__first, __last, _Integral());
+ }
+
+
+
+
+
+
+
+      ~vector()
+      { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+        _M_get_Tp_allocator()); }
+# 324 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      vector&
+      operator=(const vector& __x);
+# 374 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      void
+      assign(size_type __n, const value_type& __val)
+      { _M_fill_assign(__n, __val); }
+# 390 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      template<typename _InputIterator>
+        void
+        assign(_InputIterator __first, _InputIterator __last)
+        {
+
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_assign_dispatch(__first, __last, _Integral());
+ }
+# 417 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      using _Base::get_allocator;
+
+
+
+
+
+
+
+      iterator
+      begin()
+      { return iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      const_iterator
+      begin() const
+      { return const_iterator(this->_M_impl._M_start); }
+
+
+
+
+
+
+      iterator
+      end()
+      { return iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      const_iterator
+      end() const
+      { return const_iterator(this->_M_impl._M_finish); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(end()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+
+
+
+
+
+
+      reverse_iterator
+      rend()
+      { return reverse_iterator(begin()); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(begin()); }
+# 532 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      size_type
+      size() const
+      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }
+
+
+      size_type
+      max_size() const
+      { return _M_get_Tp_allocator().max_size(); }
+# 552 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      void
+      resize(size_type __new_size, value_type __x = value_type())
+      {
+ if (__new_size < size())
+   _M_erase_at_end(this->_M_impl._M_start + __new_size);
+ else
+   insert(end(), __new_size - size(), __x);
+      }
+# 572 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      size_type
+      capacity() const
+      { return size_type(this->_M_impl._M_end_of_storage
+    - this->_M_impl._M_start); }
+
+
+
+
+
+      bool
+      empty() const
+      { return begin() == end(); }
+# 602 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      void
+      reserve(size_type __n);
+# 617 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      reference
+      operator[](size_type __n)
+      { return *(this->_M_impl._M_start + __n); }
+# 632 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      const_reference
+      operator[](size_type __n) const
+      { return *(this->_M_impl._M_start + __n); }
+
+    public:
+
+      void
+      _M_range_check(size_type __n) const
+      {
+ if (__n >= this->size())
+   __throw_out_of_range(("vector::_M_range_check"));
+      }
+
+    public:
+# 657 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      reference
+      at(size_type __n)
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+# 675 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      const_reference
+      at(size_type __n) const
+      {
+ _M_range_check(__n);
+ return (*this)[__n];
+      }
+
+
+
+
+
+      reference
+      front()
+      { return *begin(); }
+
+
+
+
+
+      const_reference
+      front() const
+      { return *begin(); }
+
+
+
+
+
+      reference
+      back()
+      { return *(end() - 1); }
+
+
+
+
+
+      const_reference
+      back() const
+      { return *(end() - 1); }
+# 721 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      pointer
+      data()
+      { return pointer(this->_M_impl._M_start); }
+
+      const_pointer
+      data() const
+      { return const_pointer(this->_M_impl._M_start); }
+# 740 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      void
+      push_back(const value_type& __x)
+      {
+ if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+   {
+     this->_M_impl.construct(this->_M_impl._M_finish, __x);
+     ++this->_M_impl._M_finish;
+   }
+ else
+   _M_insert_aux(end(), __x);
+      }
+# 771 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      void
+      pop_back()
+      {
+ --this->_M_impl._M_finish;
+ this->_M_impl.destroy(this->_M_impl._M_finish);
+      }
+# 807 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      iterator
+      insert(iterator __position, const value_type& __x);
+# 857 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      void
+      insert(iterator __position, size_type __n, const value_type& __x)
+      { _M_fill_insert(__position, __n, __x); }
+# 875 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      template<typename _InputIterator>
+        void
+        insert(iterator __position, _InputIterator __first,
+        _InputIterator __last)
+        {
+
+   typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+   _M_insert_dispatch(__position, __first, __last, _Integral());
+ }
+# 900 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      iterator
+      erase(iterator __position);
+# 921 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      iterator
+      erase(iterator __first, iterator __last);
+# 933 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      void
+      swap(vector& __x)
+      {
+ std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+ std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+ std::swap(this->_M_impl._M_end_of_storage,
+    __x._M_impl._M_end_of_storage);
+
+
+
+ std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(),
+          __x._M_get_Tp_allocator());
+      }
+
+
+
+
+
+
+
+      void
+      clear()
+      { _M_erase_at_end(this->_M_impl._M_start); }
+
+    public:
+
+
+
+
+      template<typename _ForwardIterator>
+        pointer
+        _M_allocate_and_copy(size_type __n,
+        _ForwardIterator __first, _ForwardIterator __last)
+        {
+   pointer __result = this->_M_allocate(__n);
+   try
+     {
+       std::__uninitialized_copy_a(__first, __last, __result,
+       _M_get_Tp_allocator());
+       return __result;
+     }
+   catch(...)
+     {
+       _M_deallocate(__result, __n);
+       throw;
+     }
+ }
+# 988 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      template<typename _Integer>
+        void
+        _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type)
+        {
+   this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n));
+   this->_M_impl._M_end_of_storage =
+     this->_M_impl._M_start + static_cast<size_type>(__n);
+   _M_fill_initialize(static_cast<size_type>(__n), __value);
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+          __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_initialize(__first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_range_initialize(_InputIterator __first,
+       _InputIterator __last, std::input_iterator_tag)
+        {
+   for (; __first != __last; ++__first)
+     push_back(*__first);
+ }
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_range_initialize(_ForwardIterator __first,
+       _ForwardIterator __last, std::forward_iterator_tag)
+        {
+   const size_type __n = std::distance(__first, __last);
+   this->_M_impl._M_start = this->_M_allocate(__n);
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+   this->_M_impl._M_finish =
+     std::__uninitialized_copy_a(__first, __last,
+     this->_M_impl._M_start,
+     _M_get_Tp_allocator());
+ }
+
+
+
+      void
+      _M_fill_initialize(size_type __n, const value_type& __value)
+      {
+ std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value,
+          _M_get_Tp_allocator());
+ this->_M_impl._M_finish = this->_M_impl._M_end_of_storage;
+      }
+# 1052 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      template<typename _Integer>
+        void
+        _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+        { _M_fill_assign(__n, __val); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+      __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_assign_aux(__first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_assign_aux(_InputIterator __first, _InputIterator __last,
+        std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+        std::forward_iterator_tag);
+
+
+
+      void
+      _M_fill_assign(size_type __n, const value_type& __val);
+# 1092 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+      template<typename _Integer>
+        void
+        _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
+      __true_type)
+        { _M_fill_insert(__pos, __n, __val); }
+
+
+      template<typename _InputIterator>
+        void
+        _M_insert_dispatch(iterator __pos, _InputIterator __first,
+      _InputIterator __last, __false_type)
+        {
+   typedef typename std::iterator_traits<_InputIterator>::
+     iterator_category _IterCategory;
+   _M_range_insert(__pos, __first, __last, _IterCategory());
+ }
+
+
+      template<typename _InputIterator>
+        void
+        _M_range_insert(iterator __pos, _InputIterator __first,
+   _InputIterator __last, std::input_iterator_tag);
+
+
+      template<typename _ForwardIterator>
+        void
+        _M_range_insert(iterator __pos, _ForwardIterator __first,
+   _ForwardIterator __last, std::forward_iterator_tag);
+
+
+
+      void
+      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);
+
+
+
+      void
+      _M_insert_aux(iterator __position, const value_type& __x);
+
+
+
+
+
+
+
+      size_type
+      _M_check_len(size_type __n, const char* __s) const
+      {
+ if (max_size() - size() < __n)
+   __throw_length_error((__s));
+
+ const size_type __len = size() + std::max(size(), __n);
+ return (__len < size() || __len > max_size()) ? max_size() : __len;
+      }
+
+
+
+
+
+      void
+      _M_erase_at_end(pointer __pos)
+      {
+ std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator());
+ this->_M_impl._M_finish = __pos;
+      }
+    };
+# 1170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return (__x.size() == __y.size()
+       && std::equal(__x.begin(), __x.end(), __y.begin())); }
+# 1187 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_vector.h" 3
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end()); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline bool
+    operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Tp, typename _Alloc>
+    inline void
+    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
+    { __x.swap(__y); }
+
+}
+# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 1 3
+# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  typedef unsigned long _Bit_type;
+  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };
+
+  struct _Bit_reference
+  {
+    _Bit_type * _M_p;
+    _Bit_type _M_mask;
+
+    _Bit_reference(_Bit_type * __x, _Bit_type __y)
+    : _M_p(__x), _M_mask(__y) { }
+
+    _Bit_reference() : _M_p(0), _M_mask(0) { }
+
+    operator bool() const
+    { return !!(*_M_p & _M_mask); }
+
+    _Bit_reference&
+    operator=(bool __x)
+    {
+      if (__x)
+ *_M_p |= _M_mask;
+      else
+ *_M_p &= ~_M_mask;
+      return *this;
+    }
+
+    _Bit_reference&
+    operator=(const _Bit_reference& __x)
+    { return *this = bool(__x); }
+
+    bool
+    operator==(const _Bit_reference& __x) const
+    { return bool(*this) == bool(__x); }
+
+    bool
+    operator<(const _Bit_reference& __x) const
+    { return !bool(*this) && bool(__x); }
+
+    void
+    flip()
+    { *_M_p ^= _M_mask; }
+  };
+
+  struct _Bit_iterator_base
+  : public std::iterator<std::random_access_iterator_tag, bool>
+  {
+    _Bit_type * _M_p;
+    unsigned int _M_offset;
+
+    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
+    : _M_p(__x), _M_offset(__y) { }
+
+    void
+    _M_bump_up()
+    {
+      if (_M_offset++ == int(_S_word_bit) - 1)
+ {
+   _M_offset = 0;
+   ++_M_p;
+ }
+    }
+
+    void
+    _M_bump_down()
+    {
+      if (_M_offset-- == 0)
+ {
+   _M_offset = int(_S_word_bit) - 1;
+   --_M_p;
+ }
+    }
+
+    void
+    _M_incr(ptrdiff_t __i)
+    {
+      difference_type __n = __i + _M_offset;
+      _M_p += __n / int(_S_word_bit);
+      __n = __n % int(_S_word_bit);
+      if (__n < 0)
+ {
+   __n += int(_S_word_bit);
+   --_M_p;
+ }
+      _M_offset = static_cast<unsigned int>(__n);
+    }
+
+    bool
+    operator==(const _Bit_iterator_base& __i) const
+    { return _M_p == __i._M_p && _M_offset == __i._M_offset; }
+
+    bool
+    operator<(const _Bit_iterator_base& __i) const
+    {
+      return _M_p < __i._M_p
+      || (_M_p == __i._M_p && _M_offset < __i._M_offset);
+    }
+
+    bool
+    operator!=(const _Bit_iterator_base& __i) const
+    { return !(*this == __i); }
+
+    bool
+    operator>(const _Bit_iterator_base& __i) const
+    { return __i < *this; }
+
+    bool
+    operator<=(const _Bit_iterator_base& __i) const
+    { return !(__i < *this); }
+
+    bool
+    operator>=(const _Bit_iterator_base& __i) const
+    { return !(*this < __i); }
+  };
+
+  inline ptrdiff_t
+  operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
+  {
+    return (int(_S_word_bit) * (__x._M_p - __y._M_p)
+     + __x._M_offset - __y._M_offset);
+  }
+
+  struct _Bit_iterator : public _Bit_iterator_base
+  {
+    typedef _Bit_reference reference;
+    typedef _Bit_reference* pointer;
+    typedef _Bit_iterator iterator;
+
+    _Bit_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    reference
+    operator*() const
+    { return reference(_M_p, 1UL << _M_offset); }
+
+    iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    iterator
+    operator++(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    iterator
+    operator--(int)
+    {
+      iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    iterator
+    operator+(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp += __i;
+    }
+
+    iterator
+    operator-(difference_type __i) const
+    {
+      iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+
+    reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+
+  inline _Bit_iterator
+  operator+(ptrdiff_t __n, const _Bit_iterator& __x)
+  { return __x + __n; }
+
+  struct _Bit_const_iterator : public _Bit_iterator_base
+  {
+    typedef bool reference;
+    typedef bool const_reference;
+    typedef const bool* pointer;
+    typedef _Bit_const_iterator const_iterator;
+
+    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }
+
+    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
+    : _Bit_iterator_base(__x, __y) { }
+
+    _Bit_const_iterator(const _Bit_iterator& __x)
+    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }
+
+    const_reference
+    operator*() const
+    { return _Bit_reference(_M_p, 1UL << _M_offset); }
+
+    const_iterator&
+    operator++()
+    {
+      _M_bump_up();
+      return *this;
+    }
+
+    const_iterator
+    operator++(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_up();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator--()
+    {
+      _M_bump_down();
+      return *this;
+    }
+
+    const_iterator
+    operator--(int)
+    {
+      const_iterator __tmp = *this;
+      _M_bump_down();
+      return __tmp;
+    }
+
+    const_iterator&
+    operator+=(difference_type __i)
+    {
+      _M_incr(__i);
+      return *this;
+    }
+
+    const_iterator&
+    operator-=(difference_type __i)
+    {
+      *this += -__i;
+      return *this;
+    }
+
+    const_iterator
+    operator+(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp += __i;
+    }
+
+    const_iterator
+    operator-(difference_type __i) const
+    {
+      const_iterator __tmp = *this;
+      return __tmp -= __i;
+    }
+
+    const_reference
+    operator[](difference_type __i) const
+    { return *(*this + __i); }
+  };
+
+  inline _Bit_const_iterator
+  operator+(ptrdiff_t __n, const _Bit_const_iterator& __x)
+  { return __x + __n; }
+
+  inline void
+  __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x)
+  {
+    for (; __first != __last; ++__first)
+      *__first = __x;
+  }
+
+  inline void
+  fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x)
+  {
+    if (__first._M_p != __last._M_p)
+      {
+ std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0);
+ __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x);
+ __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x);
+      }
+    else
+      __fill_bvector(__first, __last, __x);
+  }
+
+  template<typename _Alloc>
+    struct _Bvector_base
+    {
+      typedef typename _Alloc::template rebind<_Bit_type>::other
+        _Bit_alloc_type;
+
+      struct _Bvector_impl
+      : public _Bit_alloc_type
+      {
+ _Bit_iterator _M_start;
+ _Bit_iterator _M_finish;
+ _Bit_type* _M_end_of_storage;
+
+ _Bvector_impl()
+ : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0)
+ { }
+
+ _Bvector_impl(const _Bit_alloc_type& __a)
+ : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0)
+ { }
+      };
+
+    public:
+      typedef _Alloc allocator_type;
+
+      _Bit_alloc_type&
+      _M_get_Bit_allocator()
+      { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); }
+
+      const _Bit_alloc_type&
+      _M_get_Bit_allocator() const
+      { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Bit_allocator()); }
+
+      _Bvector_base()
+      : _M_impl() { }
+
+      _Bvector_base(const allocator_type& __a)
+      : _M_impl(__a) { }
+# 429 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
+      ~_Bvector_base()
+      { this->_M_deallocate(); }
+
+    public:
+      _Bvector_impl _M_impl;
+
+      _Bit_type*
+      _M_allocate(size_t __n)
+      { return _M_impl.allocate((__n + int(_S_word_bit) - 1)
+    / int(_S_word_bit)); }
+
+      void
+      _M_deallocate()
+      {
+ if (_M_impl._M_start._M_p)
+   _M_impl.deallocate(_M_impl._M_start._M_p,
+        _M_impl._M_end_of_storage - _M_impl._M_start._M_p);
+      }
+    };
+
+}
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 473 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
+template<typename _Alloc>
+  class vector<bool, _Alloc> : public _Bvector_base<_Alloc>
+  {
+    typedef _Bvector_base<_Alloc> _Base;
+
+
+
+
+
+  public:
+    typedef bool value_type;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+    typedef _Bit_reference reference;
+    typedef bool const_reference;
+    typedef _Bit_reference* pointer;
+    typedef const bool* const_pointer;
+    typedef _Bit_iterator iterator;
+    typedef _Bit_const_iterator const_iterator;
+    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef std::reverse_iterator<iterator> reverse_iterator;
+    typedef _Alloc allocator_type;
+
+    allocator_type get_allocator() const
+    { return _Base::get_allocator(); }
+
+  public:
+    using _Base::_M_allocate;
+    using _Base::_M_deallocate;
+    using _Base::_M_get_Bit_allocator;
+
+  public:
+    vector()
+    : _Base() { }
+
+    explicit
+    vector(const allocator_type& __a)
+    : _Base(__a) { }
+
+    explicit
+    vector(size_type __n, const bool& __value = bool(),
+    const allocator_type& __a = allocator_type())
+    : _Base(__a)
+    {
+      _M_initialize(__n);
+      std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage,
+  __value ? ~0 : 0);
+    }
+
+    vector(const vector& __x)
+    : _Base(__x._M_get_Bit_allocator())
+    {
+      _M_initialize(__x.size());
+      _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start);
+    }
+# 542 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
+    template<typename _InputIterator>
+      vector(_InputIterator __first, _InputIterator __last,
+      const allocator_type& __a = allocator_type())
+      : _Base(__a)
+      {
+ typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+ _M_initialize_dispatch(__first, __last, _Integral());
+      }
+
+    ~vector() { }
+
+    vector&
+    operator=(const vector& __x)
+    {
+      if (&__x == this)
+ return *this;
+      if (__x.size() > capacity())
+ {
+   this->_M_deallocate();
+   _M_initialize(__x.size());
+ }
+      this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(),
+      begin());
+      return *this;
+    }
+# 591 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
+    void
+    assign(size_type __n, const bool& __x)
+    { _M_fill_assign(__n, __x); }
+
+    template<typename _InputIterator>
+      void
+      assign(_InputIterator __first, _InputIterator __last)
+      {
+ typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+ _M_assign_dispatch(__first, __last, _Integral());
+      }
+
+
+
+
+
+
+
+    iterator
+    begin()
+    { return this->_M_impl._M_start; }
+
+    const_iterator
+    begin() const
+    { return this->_M_impl._M_start; }
+
+    iterator
+    end()
+    { return this->_M_impl._M_finish; }
+
+    const_iterator
+    end() const
+    { return this->_M_impl._M_finish; }
+
+    reverse_iterator
+    rbegin()
+    { return reverse_iterator(end()); }
+
+    const_reverse_iterator
+    rbegin() const
+    { return const_reverse_iterator(end()); }
+
+    reverse_iterator
+    rend()
+    { return reverse_iterator(begin()); }
+
+    const_reverse_iterator
+    rend() const
+    { return const_reverse_iterator(begin()); }
+# 659 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_bvector.h" 3
+    size_type
+    size() const
+    { return size_type(end() - begin()); }
+
+    size_type
+    max_size() const
+    {
+      const size_type __isize =
+ __gnu_cxx::__numeric_traits<difference_type>::__max
+ - int(_S_word_bit) + 1;
+      const size_type __asize = _M_get_Bit_allocator().max_size();
+      return (__asize <= __isize / int(_S_word_bit)
+       ? __asize * int(_S_word_bit) : __isize);
+    }
+
+    size_type
+    capacity() const
+    { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0)
+         - begin()); }
+
+    bool
+    empty() const
+    { return begin() == end(); }
+
+    reference
+    operator[](size_type __n)
+    {
+      return *iterator(this->_M_impl._M_start._M_p
+         + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+
+    const_reference
+    operator[](size_type __n) const
+    {
+      return *const_iterator(this->_M_impl._M_start._M_p
+        + __n / int(_S_word_bit), __n % int(_S_word_bit));
+    }
+
+  public:
+    void
+    _M_range_check(size_type __n) const
+    {
+      if (__n >= this->size())
+        __throw_out_of_range(("vector<bool>::_M_range_check"));
+    }
+
+  public:
+    reference
+    at(size_type __n)
+    { _M_range_check(__n); return (*this)[__n]; }
+
+    const_reference
+    at(size_type __n) const
+    { _M_range_check(__n); return (*this)[__n]; }
+
+    void
+    reserve(size_type __n);
+
+    reference
+    front()
+    { return *begin(); }
+
+    const_reference
+    front() const
+    { return *begin(); }
+
+    reference
+    back()
+    { return *(end() - 1); }
+
+    const_reference
+    back() const
+    { return *(end() - 1); }
+
+
+
+
+
+
+    void
+    data() { }
+
+    void
+    push_back(bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(end(), __x);
+    }
+
+    void
+    swap(vector& __x)
+    {
+      std::swap(this->_M_impl._M_start, __x._M_impl._M_start);
+      std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish);
+      std::swap(this->_M_impl._M_end_of_storage,
+  __x._M_impl._M_end_of_storage);
+
+
+
+      std::__alloc_swap<typename _Base::_Bit_alloc_type>::
+ _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator());
+    }
+
+
+    static void
+    swap(reference __x, reference __y)
+    {
+      bool __tmp = __x;
+      __x = __y;
+      __y = __tmp;
+    }
+
+    iterator
+    insert(iterator __position, const bool& __x = bool())
+    {
+      const difference_type __n = __position - begin();
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage
+   && __position == end())
+        *this->_M_impl._M_finish++ = __x;
+      else
+        _M_insert_aux(__position, __x);
+      return begin() + __n;
+    }
+
+    template<typename _InputIterator>
+      void
+      insert(iterator __position,
+      _InputIterator __first, _InputIterator __last)
+      {
+ typedef typename std::__is_integer<_InputIterator>::__type _Integral;
+ _M_insert_dispatch(__position, __first, __last, _Integral());
+      }
+
+    void
+    insert(iterator __position, size_type __n, const bool& __x)
+    { _M_fill_insert(__position, __n, __x); }
+
+
+
+
+
+
+    void
+    pop_back()
+    { --this->_M_impl._M_finish; }
+
+    iterator
+    erase(iterator __position)
+    {
+      if (__position + 1 != end())
+        std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      return __position;
+    }
+
+    iterator
+    erase(iterator __first, iterator __last)
+    {
+      _M_erase_at_end(std::copy(__last, end(), __first));
+      return __first;
+    }
+
+    void
+    resize(size_type __new_size, bool __x = bool())
+    {
+      if (__new_size < size())
+        _M_erase_at_end(begin() + difference_type(__new_size));
+      else
+        insert(end(), __new_size - size(), __x);
+    }
+
+
+
+
+
+
+
+    void
+    flip()
+    {
+      for (_Bit_type * __p = this->_M_impl._M_start._M_p;
+    __p != this->_M_impl._M_end_of_storage; ++__p)
+        *__p = ~*__p;
+    }
+
+    void
+    clear()
+    { _M_erase_at_end(begin()); }
+
+
+  public:
+
+    iterator
+    _M_copy_aligned(const_iterator __first, const_iterator __last,
+      iterator __result)
+    {
+      _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p);
+      return std::copy(const_iterator(__last._M_p, 0), __last,
+         iterator(__q, 0));
+    }
+
+    void
+    _M_initialize(size_type __n)
+    {
+      _Bit_type* __q = this->_M_allocate(__n);
+      this->_M_impl._M_end_of_storage = (__q
+      + ((__n + int(_S_word_bit) - 1)
+         / int(_S_word_bit)));
+      this->_M_impl._M_start = iterator(__q, 0);
+      this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n);
+    }
+
+
+
+
+
+    template<typename _Integer>
+      void
+      _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
+      {
+ _M_initialize(static_cast<size_type>(__n));
+ std::fill(this->_M_impl._M_start._M_p,
+    this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+      }
+
+    template<typename _InputIterator>
+      void
+      _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
+        __false_type)
+      { _M_initialize_range(__first, __last,
+       std::__iterator_category(__first)); }
+
+    template<typename _InputIterator>
+      void
+      _M_initialize_range(_InputIterator __first, _InputIterator __last,
+     std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   push_back(*__first);
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last,
+     std::forward_iterator_tag)
+      {
+ const size_type __n = std::distance(__first, __last);
+ _M_initialize(__n);
+ std::copy(__first, __last, this->_M_impl._M_start);
+      }
+
+
+
+    template<typename _Integer>
+      void
+      _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
+      { _M_fill_assign(__n, __val); }
+
+    template<class _InputIterator>
+      void
+      _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
+    __false_type)
+      { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
+
+    void
+    _M_fill_assign(size_t __n, bool __x)
+    {
+      if (__n > size())
+ {
+   std::fill(this->_M_impl._M_start._M_p,
+      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+   insert(end(), __n - size(), __x);
+ }
+      else
+ {
+   _M_erase_at_end(begin() + __n);
+   std::fill(this->_M_impl._M_start._M_p,
+      this->_M_impl._M_end_of_storage, __x ? ~0 : 0);
+ }
+    }
+
+    template<typename _InputIterator>
+      void
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ iterator __cur = begin();
+ for (; __first != __last && __cur != end(); ++__cur, ++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   insert(end(), __first, __last);
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+ if (__len < size())
+   _M_erase_at_end(std::copy(__first, __last, begin()));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, begin());
+     insert(end(), __mid, __last);
+   }
+      }
+
+
+
+
+
+    template<typename _Integer>
+      void
+      _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x,
+    __true_type)
+      { _M_fill_insert(__pos, __n, __x); }
+
+    template<typename _InputIterator>
+      void
+      _M_insert_dispatch(iterator __pos,
+    _InputIterator __first, _InputIterator __last,
+    __false_type)
+      { _M_insert_range(__pos, __first, __last,
+   std::__iterator_category(__first)); }
+
+    void
+    _M_fill_insert(iterator __position, size_type __n, bool __x);
+
+    template<typename _InputIterator>
+      void
+      _M_insert_range(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   {
+     __pos = insert(__pos, *__first);
+     ++__pos;
+   }
+      }
+
+    template<typename _ForwardIterator>
+      void
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag);
+
+    void
+    _M_insert_aux(iterator __position, bool __x);
+
+    size_type
+    _M_check_len(size_type __n, const char* __s) const
+    {
+      if (max_size() - size() < __n)
+ __throw_length_error((__s));
+
+      const size_type __len = size() + std::max(size(), __n);
+      return (__len < size() || __len > max_size()) ? max_size() : __len;
+    }
+
+    void
+    _M_erase_at_end(iterator __pos)
+    { this->_M_impl._M_finish = __pos; }
+  };
+
+}
+# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   const size_type __old_size = size();
+   pointer __tmp = _M_allocate_and_copy(__n,
+   (this->_M_impl._M_start),
+   (this->_M_impl._M_finish));
+   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+   _M_get_Tp_allocator());
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __tmp;
+   this->_M_impl._M_finish = __tmp + __old_size;
+   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
+ }
+    }
+# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    insert(iterator __position, const value_type& __x)
+    {
+      const size_type __n = __position - begin();
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage
+   && __position == end())
+ {
+   this->_M_impl.construct(this->_M_impl._M_finish, __x);
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+# 126 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
+     _M_insert_aux(__position, __x);
+ }
+      return iterator(this->_M_impl._M_start + __n);
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    erase(iterator __position)
+    {
+      if (__position + 1 != end())
+ std::copy(__position + 1, end(), __position);
+      --this->_M_impl._M_finish;
+      this->_M_impl.destroy(this->_M_impl._M_finish);
+      return __position;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    typename vector<_Tp, _Alloc>::iterator
+    vector<_Tp, _Alloc>::
+    erase(iterator __first, iterator __last)
+    {
+      if (__last != end())
+ std::copy(__last, end(), __first);
+      _M_erase_at_end(__first.base() + (end() - __last));
+      return __first;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    vector<_Tp, _Alloc>&
+    vector<_Tp, _Alloc>::
+    operator=(const vector<_Tp, _Alloc>& __x)
+    {
+      if (&__x != this)
+ {
+   const size_type __xlen = __x.size();
+   if (__xlen > capacity())
+     {
+       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
+         __x.end());
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __tmp;
+       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
+     }
+   else if (size() >= __xlen)
+     {
+       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
+       end(), _M_get_Tp_allocator());
+     }
+   else
+     {
+       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
+   this->_M_impl._M_start);
+       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
+       __x._M_impl._M_finish,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+     }
+   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
+ }
+      return *this;
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_assign(size_t __n, const value_type& __val)
+    {
+      if (__n > capacity())
+ {
+   vector __tmp(__n, __val, _M_get_Tp_allocator());
+   __tmp.swap(*this);
+ }
+      else if (__n > size())
+ {
+   std::fill(begin(), end(), __val);
+   std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+     __n - size(), __val,
+     _M_get_Tp_allocator());
+   this->_M_impl._M_finish += __n - size();
+ }
+      else
+        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_InputIterator __first, _InputIterator __last,
+      std::input_iterator_tag)
+      {
+ pointer __cur(this->_M_impl._M_start);
+ for (; __first != __last && __cur != this->_M_impl._M_finish;
+      ++__cur, ++__first)
+   *__cur = *__first;
+ if (__first == __last)
+   _M_erase_at_end(__cur);
+ else
+   insert(end(), __first, __last);
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
+      std::forward_iterator_tag)
+      {
+ const size_type __len = std::distance(__first, __last);
+
+ if (__len > capacity())
+   {
+     pointer __tmp(_M_allocate_and_copy(__len, __first, __last));
+     std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+     _M_get_Tp_allocator());
+     _M_deallocate(this->_M_impl._M_start,
+     this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_start);
+     this->_M_impl._M_start = __tmp;
+     this->_M_impl._M_finish = this->_M_impl._M_start + __len;
+     this->_M_impl._M_end_of_storage = this->_M_impl._M_finish;
+   }
+ else if (size() >= __len)
+   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
+ else
+   {
+     _ForwardIterator __mid = __first;
+     std::advance(__mid, size());
+     std::copy(__first, __mid, this->_M_impl._M_start);
+     this->_M_impl._M_finish =
+       std::__uninitialized_copy_a(__mid, __last,
+       this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+   }
+      }
+# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/vector.tcc" 3
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_insert_aux(iterator __position, const _Tp& __x)
+
+    {
+      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
+ {
+   this->_M_impl.construct(this->_M_impl._M_finish,
+      (*(this->_M_impl._M_finish - 1))
+             );
+   ++this->_M_impl._M_finish;
+
+   _Tp __x_copy = __x;
+
+   std::copy_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1)
+
+                                  ;
+
+   *__position = __x_copy;
+
+
+
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector::_M_insert_aux");
+   const size_type __elems_before = __position - begin();
+   pointer __new_start(this->_M_allocate(__len));
+   pointer __new_finish(__new_start);
+   try
+     {
+
+
+
+
+       this->_M_impl.construct(__new_start + __elems_before,
+
+
+
+                               __x);
+
+       __new_finish = 0;
+
+       __new_finish =
+  std::__uninitialized_move_a(this->_M_impl._M_start,
+         __position.base(), __new_start,
+         _M_get_Tp_allocator());
+       ++__new_finish;
+
+       __new_finish =
+  std::__uninitialized_move_a(__position.base(),
+         this->_M_impl._M_finish,
+         __new_finish,
+         _M_get_Tp_allocator());
+     }
+          catch(...)
+     {
+       if (!__new_finish)
+  this->_M_impl.destroy(__new_start + __elems_before);
+       else
+  std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator());
+       _M_deallocate(__new_start, __len);
+       throw;
+     }
+   std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+   _M_get_Tp_allocator());
+   _M_deallocate(this->_M_impl._M_start,
+   this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_start);
+   this->_M_impl._M_start = __new_start;
+   this->_M_impl._M_finish = __new_finish;
+   this->_M_impl._M_end_of_storage = __new_start + __len;
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    void
+    vector<_Tp, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, const value_type& __x)
+    {
+      if (__n != 0)
+ {
+   if (size_type(this->_M_impl._M_end_of_storage
+   - this->_M_impl._M_finish) >= __n)
+     {
+       value_type __x_copy = __x;
+       const size_type __elems_after = end() - __position;
+       pointer __old_finish(this->_M_impl._M_finish);
+       if (__elems_after > __n)
+  {
+    std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+           this->_M_impl._M_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __n;
+    std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
+                                        ;
+    std::fill(__position.base(), __position.base() + __n,
+       __x_copy);
+  }
+       else
+  {
+    std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
+      __n - __elems_after,
+      __x_copy,
+      _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __n - __elems_after;
+    std::__uninitialized_move_a(__position.base(), __old_finish,
+           this->_M_impl._M_finish,
+           _M_get_Tp_allocator());
+    this->_M_impl._M_finish += __elems_after;
+    std::fill(__position.base(), __old_finish, __x_copy);
+  }
+     }
+   else
+     {
+       const size_type __len =
+  _M_check_len(__n, "vector::_M_fill_insert");
+       const size_type __elems_before = __position - begin();
+       pointer __new_start(this->_M_allocate(__len));
+       pointer __new_finish(__new_start);
+       try
+  {
+
+    std::__uninitialized_fill_n_a(__new_start + __elems_before,
+      __n, __x,
+      _M_get_Tp_allocator());
+    __new_finish = 0;
+
+    __new_finish =
+      std::__uninitialized_move_a(this->_M_impl._M_start,
+      __position.base(),
+      __new_start,
+      _M_get_Tp_allocator());
+    __new_finish += __n;
+
+    __new_finish =
+      std::__uninitialized_move_a(__position.base(),
+      this->_M_impl._M_finish,
+      __new_finish,
+      _M_get_Tp_allocator());
+  }
+       catch(...)
+  {
+    if (!__new_finish)
+      std::_Destroy(__new_start + __elems_before,
+      __new_start + __elems_before + __n,
+      _M_get_Tp_allocator());
+    else
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+    _M_deallocate(__new_start, __len);
+    throw;
+  }
+       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+       _M_get_Tp_allocator());
+       _M_deallocate(this->_M_impl._M_start,
+       this->_M_impl._M_end_of_storage
+       - this->_M_impl._M_start);
+       this->_M_impl._M_start = __new_start;
+       this->_M_impl._M_finish = __new_finish;
+       this->_M_impl._M_end_of_storage = __new_start + __len;
+     }
+ }
+    }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _InputIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __pos, _InputIterator __first,
+        _InputIterator __last, std::input_iterator_tag)
+      {
+ for (; __first != __last; ++__first)
+   {
+     __pos = insert(__pos, *__first);
+     ++__pos;
+   }
+      }
+
+  template<typename _Tp, typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<_Tp, _Alloc>::
+      _M_range_insert(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     const size_type __n = std::distance(__first, __last);
+     if (size_type(this->_M_impl._M_end_of_storage
+     - this->_M_impl._M_finish) >= __n)
+       {
+  const size_type __elems_after = end() - __position;
+  pointer __old_finish(this->_M_impl._M_finish);
+  if (__elems_after > __n)
+    {
+      std::__uninitialized_move_a(this->_M_impl._M_finish - __n,
+      this->_M_impl._M_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n;
+      std::copy_backward(__position.base(), __old_finish - __n, __old_finish)
+                                          ;
+      std::copy(__first, __last, __position);
+    }
+  else
+    {
+      _ForwardIterator __mid = __first;
+      std::advance(__mid, __elems_after);
+      std::__uninitialized_copy_a(__mid, __last,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __n - __elems_after;
+      std::__uninitialized_move_a(__position.base(),
+      __old_finish,
+      this->_M_impl._M_finish,
+      _M_get_Tp_allocator());
+      this->_M_impl._M_finish += __elems_after;
+      std::copy(__first, __mid, __position);
+    }
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector::_M_range_insert");
+  pointer __new_start(this->_M_allocate(__len));
+  pointer __new_finish(__new_start);
+  try
+    {
+      __new_finish =
+        std::__uninitialized_move_a(this->_M_impl._M_start,
+        __position.base(),
+        __new_start,
+        _M_get_Tp_allocator());
+      __new_finish =
+        std::__uninitialized_copy_a(__first, __last,
+        __new_finish,
+        _M_get_Tp_allocator());
+      __new_finish =
+        std::__uninitialized_move_a(__position.base(),
+        this->_M_impl._M_finish,
+        __new_finish,
+        _M_get_Tp_allocator());
+    }
+  catch(...)
+    {
+      std::_Destroy(__new_start, __new_finish,
+      _M_get_Tp_allocator());
+      _M_deallocate(__new_start, __len);
+      throw;
+    }
+  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
+         _M_get_Tp_allocator());
+  _M_deallocate(this->_M_impl._M_start,
+         this->_M_impl._M_end_of_storage
+         - this->_M_impl._M_start);
+  this->_M_impl._M_start = __new_start;
+  this->_M_impl._M_finish = __new_finish;
+  this->_M_impl._M_end_of_storage = __new_start + __len;
+       }
+   }
+      }
+
+
+
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    reserve(size_type __n)
+    {
+      if (__n > this->max_size())
+ __throw_length_error(("vector::reserve"));
+      if (this->capacity() < __n)
+ {
+   _Bit_type* __q = this->_M_allocate(__n);
+   this->_M_impl._M_finish = _M_copy_aligned(begin(), end(),
+          iterator(__q, 0));
+   this->_M_deallocate();
+   this->_M_impl._M_start = iterator(__q, 0);
+   this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1)
+          / int(_S_word_bit));
+ }
+    }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_fill_insert(iterator __position, size_type __n, bool __x)
+    {
+      if (__n == 0)
+ return;
+      if (capacity() - size() >= __n)
+ {
+   std::copy_backward(__position, end(),
+        this->_M_impl._M_finish + difference_type(__n));
+   std::fill(__position, __position + difference_type(__n), __x);
+   this->_M_impl._M_finish += difference_type(__n);
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(__n, "vector<bool>::_M_fill_insert");
+   _Bit_type * __q = this->_M_allocate(__len);
+   iterator __i = _M_copy_aligned(begin(), __position,
+      iterator(__q, 0));
+   std::fill(__i, __i + difference_type(__n), __x);
+   this->_M_impl._M_finish = std::copy(__position, end(),
+           __i + difference_type(__n));
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = (__q + ((__len
+           + int(_S_word_bit) - 1)
+          / int(_S_word_bit)));
+   this->_M_impl._M_start = iterator(__q, 0);
+ }
+    }
+
+  template<typename _Alloc>
+    template<typename _ForwardIterator>
+      void
+      vector<bool, _Alloc>::
+      _M_insert_range(iterator __position, _ForwardIterator __first,
+        _ForwardIterator __last, std::forward_iterator_tag)
+      {
+ if (__first != __last)
+   {
+     size_type __n = std::distance(__first, __last);
+     if (capacity() - size() >= __n)
+       {
+  std::copy_backward(__position, end(),
+       this->_M_impl._M_finish
+       + difference_type(__n));
+  std::copy(__first, __last, __position);
+  this->_M_impl._M_finish += difference_type(__n);
+       }
+     else
+       {
+  const size_type __len =
+    _M_check_len(__n, "vector<bool>::_M_insert_range");
+  _Bit_type * __q = this->_M_allocate(__len);
+  iterator __i = _M_copy_aligned(begin(), __position,
+            iterator(__q, 0));
+  __i = std::copy(__first, __last, __i);
+  this->_M_impl._M_finish = std::copy(__position, end(), __i);
+  this->_M_deallocate();
+  this->_M_impl._M_end_of_storage = (__q
+         + ((__len
+             + int(_S_word_bit) - 1)
+            / int(_S_word_bit)));
+  this->_M_impl._M_start = iterator(__q, 0);
+       }
+   }
+      }
+
+  template<typename _Alloc>
+    void
+    vector<bool, _Alloc>::
+    _M_insert_aux(iterator __position, bool __x)
+    {
+      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage)
+ {
+   std::copy_backward(__position, this->_M_impl._M_finish,
+        this->_M_impl._M_finish + 1);
+   *__position = __x;
+   ++this->_M_impl._M_finish;
+ }
+      else
+ {
+   const size_type __len =
+     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
+   _Bit_type * __q = this->_M_allocate(__len);
+   iterator __i = _M_copy_aligned(begin(), __position,
+      iterator(__q, 0));
+   *__i++ = __x;
+   this->_M_impl._M_finish = std::copy(__position, end(), __i);
+   this->_M_deallocate();
+   this->_M_impl._M_end_of_storage = (__q + ((__len
+           + int(_S_word_bit) - 1)
+          / int(_S_word_bit)));
+   this->_M_impl._M_start = iterator(__q, 0);
+ }
+    }
+
+}
+# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/vector" 2 3
+# 53 "/usr/include/qt4/QtCore/qvector.h" 2
+
+# 1 "/usr/include/stdlib.h" 1 3 4
+# 33 "/usr/include/stdlib.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 34 "/usr/include/stdlib.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+
+# 1 "/usr/include/bits/waitflags.h" 1 3 4
+# 43 "/usr/include/stdlib.h" 2 3 4
+# 1 "/usr/include/bits/waitstatus.h" 1 3 4
+# 67 "/usr/include/bits/waitstatus.h" 3 4
+union wait
+  {
+    int w_status;
+    struct
+      {
+
+ unsigned int __w_termsig:7;
+ unsigned int __w_coredump:1;
+ unsigned int __w_retcode:8;
+ unsigned int:16;
+
+
+
+
+
+
+
+      } __wait_terminated;
+    struct
+      {
+
+ unsigned int __w_stopval:8;
+ unsigned int __w_stopsig:8;
+ unsigned int:16;
+
+
+
+
+
+
+      } __wait_stopped;
+  };
+# 44 "/usr/include/stdlib.h" 2 3 4
+# 96 "/usr/include/stdlib.h" 3 4
+
+
+typedef struct
+  {
+    int quot;
+    int rem;
+  } div_t;
+
+
+
+typedef struct
+  {
+    long int quot;
+    long int rem;
+  } ldiv_t;
+
+
+
+
+
+
+
+__extension__ typedef struct
+  {
+    long long int quot;
+    long long int rem;
+  } lldiv_t;
+
+
+# 140 "/usr/include/stdlib.h" 3 4
+extern size_t __ctype_get_mb_cur_max (void) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern double atof (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+extern int atoi (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+extern long int atol (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+__extension__ extern long long int atoll (__const char *__nptr)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern double strtod (__const char *__restrict __nptr,
+        char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern float strtof (__const char *__restrict __nptr,
+       char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+extern long double strtold (__const char *__restrict __nptr,
+       char **__restrict __endptr)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern long int strtol (__const char *__restrict __nptr,
+   char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+extern unsigned long int strtoul (__const char *__restrict __nptr,
+      char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+__extension__
+extern long long int strtoq (__const char *__restrict __nptr,
+        char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+__extension__
+extern unsigned long long int strtouq (__const char *__restrict __nptr,
+           char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+__extension__
+extern long long int strtoll (__const char *__restrict __nptr,
+         char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+__extension__
+extern unsigned long long int strtoull (__const char *__restrict __nptr,
+     char **__restrict __endptr, int __base)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+# 240 "/usr/include/stdlib.h" 3 4
+extern long int strtol_l (__const char *__restrict __nptr,
+     char **__restrict __endptr, int __base,
+     __locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+
+extern unsigned long int strtoul_l (__const char *__restrict __nptr,
+        char **__restrict __endptr,
+        int __base, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+
+__extension__
+extern long long int strtoll_l (__const char *__restrict __nptr,
+    char **__restrict __endptr, int __base,
+    __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+
+__extension__
+extern unsigned long long int strtoull_l (__const char *__restrict __nptr,
+       char **__restrict __endptr,
+       int __base, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 4))) __attribute__ ((__warn_unused_result__));
+
+extern double strtod_l (__const char *__restrict __nptr,
+   char **__restrict __endptr, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+
+extern float strtof_l (__const char *__restrict __nptr,
+         char **__restrict __endptr, __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+
+extern long double strtold_l (__const char *__restrict __nptr,
+         char **__restrict __endptr,
+         __locale_t __loc)
+     throw () __attribute__ ((__nonnull__ (1, 3))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) double
+atof (__const char *__nptr) throw ()
+{
+  return strtod (__nptr, (char **) __null);
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+atoi (__const char *__nptr) throw ()
+{
+  return (int) strtol (__nptr, (char **) __null, 10);
+}
+extern __inline __attribute__ ((__gnu_inline__)) long int
+atol (__const char *__nptr) throw ()
+{
+  return strtol (__nptr, (char **) __null, 10);
+}
+
+
+
+
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
+atoll (__const char *__nptr) throw ()
+{
+  return strtoll (__nptr, (char **) __null, 10);
+}
+
+# 311 "/usr/include/stdlib.h" 3 4
+extern char *l64a (long int __n) throw () __attribute__ ((__warn_unused_result__));
+
+
+extern long int a64l (__const char *__s)
+     throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+# 1 "/usr/include/sys/types.h" 1 3 4
+# 29 "/usr/include/sys/types.h" 3 4
+extern "C" {
+
+
+
+
+
+typedef __u_char u_char;
+typedef __u_short u_short;
+typedef __u_int u_int;
+typedef __u_long u_long;
+typedef __quad_t quad_t;
+typedef __u_quad_t u_quad_t;
+typedef __fsid_t fsid_t;
+
+
+
+
+typedef __loff_t loff_t;
+
+
+
+typedef __ino_t ino_t;
+
+
+
+
+
+
+typedef __ino64_t ino64_t;
+
+
+
+
+typedef __dev_t dev_t;
+# 72 "/usr/include/sys/types.h" 3 4
+typedef __mode_t mode_t;
+
+
+
+
+typedef __nlink_t nlink_t;
+# 105 "/usr/include/sys/types.h" 3 4
+typedef __id_t id_t;
+# 116 "/usr/include/sys/types.h" 3 4
+typedef __daddr_t daddr_t;
+typedef __caddr_t caddr_t;
+
+
+
+
+
+typedef __key_t key_t;
+# 141 "/usr/include/sys/types.h" 3 4
+typedef __suseconds_t suseconds_t;
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 148 "/usr/include/sys/types.h" 2 3 4
+
+
+
+typedef unsigned long int ulong;
+typedef unsigned short int ushort;
+typedef unsigned int uint;
+# 195 "/usr/include/sys/types.h" 3 4
+typedef int int8_t __attribute__ ((__mode__ (__QI__)));
+typedef int int16_t __attribute__ ((__mode__ (__HI__)));
+typedef int int32_t __attribute__ ((__mode__ (__SI__)));
+typedef int int64_t __attribute__ ((__mode__ (__DI__)));
+
+
+typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
+typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
+typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
+typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
+
+typedef int register_t __attribute__ ((__mode__ (__word__)));
+# 220 "/usr/include/sys/types.h" 3 4
+# 1 "/usr/include/sys/select.h" 1 3 4
+# 31 "/usr/include/sys/select.h" 3 4
+# 1 "/usr/include/bits/select.h" 1 3 4
+# 23 "/usr/include/bits/select.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 24 "/usr/include/bits/select.h" 2 3 4
+# 32 "/usr/include/sys/select.h" 2 3 4
+
+
+# 1 "/usr/include/bits/sigset.h" 1 3 4
+# 35 "/usr/include/sys/select.h" 2 3 4
+# 46 "/usr/include/sys/select.h" 3 4
+# 1 "/usr/include/bits/time.h" 1 3 4
+# 69 "/usr/include/bits/time.h" 3 4
+struct timeval
+  {
+    __time_t tv_sec;
+    __suseconds_t tv_usec;
+  };
+# 47 "/usr/include/sys/select.h" 2 3 4
+# 55 "/usr/include/sys/select.h" 3 4
+typedef long int __fd_mask;
+# 67 "/usr/include/sys/select.h" 3 4
+typedef struct
+  {
+
+
+
+    __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
+
+
+
+
+
+  } fd_set;
+
+
+
+
+
+
+typedef __fd_mask fd_mask;
+# 99 "/usr/include/sys/select.h" 3 4
+extern "C" {
+# 109 "/usr/include/sys/select.h" 3 4
+extern int select (int __nfds, fd_set *__restrict __readfds,
+     fd_set *__restrict __writefds,
+     fd_set *__restrict __exceptfds,
+     struct timeval *__restrict __timeout);
+# 121 "/usr/include/sys/select.h" 3 4
+extern int pselect (int __nfds, fd_set *__restrict __readfds,
+      fd_set *__restrict __writefds,
+      fd_set *__restrict __exceptfds,
+      const struct timespec *__restrict __timeout,
+      const __sigset_t *__restrict __sigmask);
+
+
+}
+# 221 "/usr/include/sys/types.h" 2 3 4
+
+
+# 1 "/usr/include/sys/sysmacros.h" 1 3 4
+# 30 "/usr/include/sys/sysmacros.h" 3 4
+__extension__
+extern unsigned int gnu_dev_major (unsigned long long int __dev)
+     throw ();
+__extension__
+extern unsigned int gnu_dev_minor (unsigned long long int __dev)
+     throw ();
+__extension__
+extern unsigned long long int gnu_dev_makedev (unsigned int __major,
+            unsigned int __minor)
+     throw ();
+
+
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned int
+gnu_dev_major (unsigned long long int __dev) throw ()
+{
+  return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff);
+}
+
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned int
+gnu_dev_minor (unsigned long long int __dev) throw ()
+{
+  return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff);
+}
+
+__extension__ extern __inline __attribute__ ((__gnu_inline__)) unsigned long long int
+gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw ()
+{
+  return ((__minor & 0xff) | ((__major & 0xfff) << 8)
+   | (((unsigned long long int) (__minor & ~0xff)) << 12)
+   | (((unsigned long long int) (__major & ~0xfff)) << 32));
+}
+# 224 "/usr/include/sys/types.h" 2 3 4
+
+
+
+
+typedef __blksize_t blksize_t;
+
+
+
+
+
+
+typedef __blkcnt_t blkcnt_t;
+
+
+
+typedef __fsblkcnt_t fsblkcnt_t;
+
+
+
+typedef __fsfilcnt_t fsfilcnt_t;
+# 262 "/usr/include/sys/types.h" 3 4
+typedef __blkcnt64_t blkcnt64_t;
+typedef __fsblkcnt64_t fsblkcnt64_t;
+typedef __fsfilcnt64_t fsfilcnt64_t;
+# 273 "/usr/include/sys/types.h" 3 4
+}
+# 321 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+
+
+extern long int random (void) throw ();
+
+
+extern void srandom (unsigned int __seed) throw ();
+
+
+
+
+
+extern char *initstate (unsigned int __seed, char *__statebuf,
+   size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+struct random_data
+  {
+    int32_t *fptr;
+    int32_t *rptr;
+    int32_t *state;
+    int rand_type;
+    int rand_deg;
+    int rand_sep;
+    int32_t *end_ptr;
+  };
+
+extern int random_r (struct random_data *__restrict __buf,
+       int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int srandom_r (unsigned int __seed, struct random_data *__buf)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
+   size_t __statelen,
+   struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (2, 4)));
+
+extern int setstate_r (char *__restrict __statebuf,
+         struct random_data *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int rand (void) throw ();
+
+extern void srand (unsigned int __seed) throw ();
+
+
+
+
+extern int rand_r (unsigned int *__seed) throw ();
+
+
+
+
+
+
+
+extern double drand48 (void) throw ();
+extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int lrand48 (void) throw ();
+extern long int nrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern long int mrand48 (void) throw ();
+extern long int jrand48 (unsigned short int __xsubi[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern void srand48 (long int __seedval) throw ();
+extern unsigned short int *seed48 (unsigned short int __seed16v[3])
+     throw () __attribute__ ((__nonnull__ (1)));
+extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+struct drand48_data
+  {
+    unsigned short int __x[3];
+    unsigned short int __old_x[3];
+    unsigned short int __c;
+    unsigned short int __init;
+    unsigned long long int __a;
+  };
+
+
+extern int drand48_r (struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int erand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int lrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int nrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int mrand48_r (struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int jrand48_r (unsigned short int __xsubi[3],
+        struct drand48_data *__restrict __buffer,
+        long int *__restrict __result)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+extern int seed48_r (unsigned short int __seed16v[3],
+       struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+extern int lcong48_r (unsigned short int __param[7],
+        struct drand48_data *__buffer)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+
+
+
+extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+
+extern void *calloc (size_t __nmemb, size_t __size)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+
+
+
+extern void *realloc (void *__ptr, size_t __size)
+     throw () __attribute__ ((__warn_unused_result__));
+
+extern void free (void *__ptr) throw ();
+
+
+
+
+extern void cfree (void *__ptr) throw ();
+
+
+
+# 1 "/usr/include/alloca.h" 1 3 4
+# 25 "/usr/include/alloca.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 26 "/usr/include/alloca.h" 2 3 4
+
+extern "C" {
+
+
+
+
+
+extern void *alloca (size_t __size) throw ();
+
+
+
+
+
+}
+# 498 "/usr/include/stdlib.h" 2 3 4
+
+
+
+
+extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern void abort (void) throw () __attribute__ ((__noreturn__));
+
+
+
+extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern "C++" int at_quick_exit (void (*__func) (void))
+     throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+
+
+extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern void exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern char *__secure_getenv (__const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int setenv (__const char *__name, __const char *__value, int __replace)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int unsetenv (__const char *__name) throw ();
+
+
+
+
+
+
+extern int clearenv (void) throw ();
+# 604 "/usr/include/stdlib.h" 3 4
+extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 615 "/usr/include/stdlib.h" 3 4
+extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 625 "/usr/include/stdlib.h" 3 4
+extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 637 "/usr/include/stdlib.h" 3 4
+extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 647 "/usr/include/stdlib.h" 3 4
+extern int mkstemps64 (char *__template, int __suffixlen)
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 658 "/usr/include/stdlib.h" 3 4
+extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 669 "/usr/include/stdlib.h" 3 4
+extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 679 "/usr/include/stdlib.h" 3 4
+extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 689 "/usr/include/stdlib.h" 3 4
+extern int mkostemps (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 701 "/usr/include/stdlib.h" 3 4
+extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
+     __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+
+
+extern int system (__const char *__command) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern char *canonicalize_file_name (__const char *__name)
+     throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 729 "/usr/include/stdlib.h" 3 4
+extern char *realpath (__const char *__restrict __name,
+         char *__restrict __resolved) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+typedef int (*__compar_fn_t) (__const void *, __const void *);
+
+
+typedef __compar_fn_t comparison_fn_t;
+
+
+
+typedef int (*__compar_d_fn_t) (__const void *, __const void *, void *);
+
+
+
+
+
+extern void *bsearch (__const void *__key, __const void *__base,
+        size_t __nmemb, size_t __size, __compar_fn_t __compar)
+     __attribute__ ((__nonnull__ (1, 2, 5))) __attribute__ ((__warn_unused_result__));
+
+
+
+extern void qsort (void *__base, size_t __nmemb, size_t __size,
+     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
+
+extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
+       __compar_d_fn_t __compar, void *__arg)
+  __attribute__ ((__nonnull__ (1, 4)));
+
+
+
+
+extern int abs (int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+extern long int labs (long int __x) throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+
+
+
+__extension__ extern long long int llabs (long long int __x)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+extern div_t div (int __numer, int __denom)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+extern ldiv_t ldiv (long int __numer, long int __denom)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+
+
+
+
+__extension__ extern lldiv_t lldiv (long long int __numer,
+        long long int __denom)
+     throw () __attribute__ ((__const__)) __attribute__ ((__warn_unused_result__));
+
+# 802 "/usr/include/stdlib.h" 3 4
+extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern char *gcvt (double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern char *qecvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+extern char *qfcvt (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign)
+     throw () __attribute__ ((__nonnull__ (3, 4))) __attribute__ ((__warn_unused_result__));
+extern char *qgcvt (long double __value, int __ndigit, char *__buf)
+     throw () __attribute__ ((__nonnull__ (3))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
+     int *__restrict __sign, char *__restrict __buf,
+     size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+extern int qecvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+extern int qfcvt_r (long double __value, int __ndigit,
+      int *__restrict __decpt, int *__restrict __sign,
+      char *__restrict __buf, size_t __len)
+     throw () __attribute__ ((__nonnull__ (3, 4, 5)));
+
+
+
+
+
+
+
+extern int mblen (__const char *__s, size_t __n) throw () __attribute__ ((__warn_unused_result__));
+
+
+extern int mbtowc (wchar_t *__restrict __pwc,
+     __const char *__restrict __s, size_t __n) throw () __attribute__ ((__warn_unused_result__));
+
+
+extern int wctomb (char *__s, wchar_t __wchar) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+extern size_t mbstowcs (wchar_t *__restrict __pwcs,
+   __const char *__restrict __s, size_t __n) throw ();
+
+extern size_t wcstombs (char *__restrict __s,
+   __const wchar_t *__restrict __pwcs, size_t __n)
+     throw ();
+
+
+
+
+
+
+
+
+extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
+# 890 "/usr/include/stdlib.h" 3 4
+extern int getsubopt (char **__restrict __optionp,
+        char *__const *__restrict __tokens,
+        char **__restrict __valuep)
+     throw () __attribute__ ((__nonnull__ (1, 2, 3))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+
+extern int posix_openpt (int __oflag) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+extern int grantpt (int __fd) throw ();
+
+
+
+extern int unlockpt (int __fd) throw ();
+
+
+
+
+extern char *ptsname (int __fd) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+extern int getpt (void);
+
+
+
+
+
+
+extern int getloadavg (double __loadavg[], int __nelem)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+# 1 "/usr/include/bits/stdlib.h" 1 3 4
+# 24 "/usr/include/bits/stdlib.h" 3 4
+extern char *__realpath_chk (__const char *__restrict __name,
+        char *__restrict __resolved,
+        size_t __resolvedlen) throw () __attribute__ ((__warn_unused_result__));
+extern char *__realpath_alias (__const char *__restrict __name, char *__restrict __resolved) throw () __asm__ ("" "realpath")
+
+                                                 __attribute__ ((__warn_unused_result__));
+extern char *__realpath_chk_warn (__const char *__restrict __name, char *__restrict __resolved, size_t __resolvedlen) throw () __asm__ ("" "__realpath_chk")
+
+
+                                                __attribute__ ((__warn_unused_result__))
+     __attribute__((__warning__ ("second argument of realpath must be either NULL or at " "least PATH_MAX bytes long buffer")))
+                                      ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+realpath (__const char *__restrict __name, char *__restrict __resolved) throw ()
+{
+  if (__builtin_object_size (__resolved, 2 > 1) != (size_t) -1)
+    {
+
+
+
+
+      return __realpath_chk (__name, __resolved, __builtin_object_size (__resolved, 2 > 1));
+    }
+
+  return __realpath_alias (__name, __resolved);
+}
+
+
+extern int __ptsname_r_chk (int __fd, char *__buf, size_t __buflen,
+       size_t __nreal) throw () __attribute__ ((__nonnull__ (2)));
+extern int __ptsname_r_alias (int __fd, char *__buf, size_t __buflen) throw () __asm__ ("" "ptsname_r")
+
+     __attribute__ ((__nonnull__ (2)));
+extern int __ptsname_r_chk_warn (int __fd, char *__buf, size_t __buflen, size_t __nreal) throw () __asm__ ("" "__ptsname_r_chk")
+
+
+     __attribute__ ((__nonnull__ (2))) __attribute__((__warning__ ("ptsname_r called with buflen bigger than " "size of buf")))
+                   ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+ptsname_r (int __fd, char *__buf, size_t __buflen) throw ()
+{
+  if (__builtin_object_size (__buf, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__buflen))
+ return __ptsname_r_chk (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+      if (__buflen > __builtin_object_size (__buf, 2 > 1))
+ return __ptsname_r_chk_warn (__fd, __buf, __buflen, __builtin_object_size (__buf, 2 > 1));
+    }
+  return __ptsname_r_alias (__fd, __buf, __buflen);
+}
+
+
+extern int __wctomb_chk (char *__s, wchar_t __wchar, size_t __buflen)
+  throw () __attribute__ ((__warn_unused_result__));
+extern int __wctomb_alias (char *__s, wchar_t __wchar) throw () __asm__ ("" "wctomb")
+              __attribute__ ((__warn_unused_result__));
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) int
+wctomb (char *__s, wchar_t __wchar) throw ()
+{
+
+
+
+
+
+
+
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1 && 16 > __builtin_object_size (__s, 2 > 1))
+    return __wctomb_chk (__s, __wchar, __builtin_object_size (__s, 2 > 1));
+  return __wctomb_alias (__s, __wchar);
+}
+
+
+extern size_t __mbstowcs_chk (wchar_t *__restrict __dst,
+         __const char *__restrict __src,
+         size_t __len, size_t __dstlen) throw ();
+extern size_t __mbstowcs_alias (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len) throw () __asm__ ("" "mbstowcs")
+
+
+                                  ;
+extern size_t __mbstowcs_chk_warn (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__mbstowcs_chk")
+
+
+
+     __attribute__((__warning__ ("mbstowcs called with dst buffer smaller than len " "* sizeof (wchar_t)")))
+                        ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+mbstowcs (wchar_t *__restrict __dst, __const char *__restrict __src, size_t __len) throw ()
+
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __mbstowcs_chk (__dst, __src, __len,
+          __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+
+      if (__len > __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t))
+ return __mbstowcs_chk_warn (__dst, __src, __len,
+         __builtin_object_size (__dst, 2 > 1) / sizeof (wchar_t));
+    }
+  return __mbstowcs_alias (__dst, __src, __len);
+}
+
+
+extern size_t __wcstombs_chk (char *__restrict __dst,
+         __const wchar_t *__restrict __src,
+         size_t __len, size_t __dstlen) throw ();
+extern size_t __wcstombs_alias (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len) throw () __asm__ ("" "wcstombs")
+
+
+                                  ;
+extern size_t __wcstombs_chk_warn (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len, size_t __dstlen) throw () __asm__ ("" "__wcstombs_chk")
+
+
+
+     __attribute__((__warning__ ("wcstombs called with dst buffer smaller than len")));
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) size_t
+wcstombs (char *__restrict __dst, __const wchar_t *__restrict __src, size_t __len) throw ()
+
+{
+  if (__builtin_object_size (__dst, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__len))
+ return __wcstombs_chk (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
+      if (__len > __builtin_object_size (__dst, 2 > 1))
+ return __wcstombs_chk_warn (__dst, __src, __len, __builtin_object_size (__dst, 2 > 1));
+    }
+  return __wcstombs_alias (__dst, __src, __len);
+}
+# 950 "/usr/include/stdlib.h" 2 3 4
+# 958 "/usr/include/stdlib.h" 3 4
+}
+# 55 "/usr/include/qt4/QtCore/qvector.h" 2
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+struct QVectorData
+{
+    QBasicAtomicInt ref;
+    int alloc;
+    int size;
+
+
+
+
+
+
+    uint sharable : 1;
+    uint capacity : 1;
+    uint reserved : 30;
+
+
+    static QVectorData shared_null;
+
+
+
+    static QVectorData *malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init);
+    static QVectorData *allocate(int size, int alignment);
+    static QVectorData *reallocate(QVectorData *old, int newsize, int oldsize, int alignment);
+    static void free(QVectorData *data, int alignment);
+    static int grow(int sizeofTypedData, int size, int sizeofT, bool excessive);
+};
+
+template <typename T>
+struct QVectorTypedData : private QVectorData
+{
+
+    T array[1];
+
+    static inline void free(QVectorTypedData<T> *x, int alignment) { QVectorData::free(static_cast<QVectorData *>(x), alignment); }
+};
+
+class QRegion;
+
+template <typename T>
+class QVector
+{
+    typedef QVectorTypedData<T> Data;
+    union {
+        QVectorData *d;
+
+
+
+        Data *p;
+
+    };
+
+public:
+    inline QVector() : d(&QVectorData::shared_null) { d->ref.ref(); }
+    explicit QVector(int size);
+    QVector(int size, const T &t);
+    inline QVector(const QVector<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+    inline ~QVector() { if (!d) return; if (!d->ref.deref()) free(p); }
+    QVector<T> &operator=(const QVector<T> &v);
+    bool operator==(const QVector<T> &v) const;
+    inline bool operator!=(const QVector<T> &v) const { return !(*this == v); }
+
+    inline int size() const { return d->size; }
+
+    inline bool isEmpty() const { return d->size == 0; }
+
+    void resize(int size);
+
+    inline int capacity() const { return d->alloc; }
+    void reserve(int size);
+    inline void squeeze() { realloc(d->size, d->size); d->capacity = 0; }
+
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+
+    inline T *data() { detach(); return p->array; }
+    inline const T *data() const { return p->array; }
+    inline const T *constData() const { return p->array; }
+    void clear();
+
+    const T &at(int i) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+    void append(const T &t);
+    void prepend(const T &t);
+    void insert(int i, const T &t);
+    void insert(int i, int n, const T &t);
+    void replace(int i, const T &t);
+    void remove(int i);
+    void remove(int i, int n);
+
+    QVector<T> &fill(const T &t, int size = -1);
+
+    int indexOf(const T &t, int from = 0) const;
+    int lastIndexOf(const T &t, int from = -1) const;
+    bool contains(const T &t) const;
+    int count(const T &t) const;
+# 230 "/usr/include/qt4/QtCore/qvector.h"
+    typedef T* iterator;
+    typedef const T* const_iterator;
+
+    inline iterator begin() { detach(); return p->array; }
+    inline const_iterator begin() const { return p->array; }
+    inline const_iterator constBegin() const { return p->array; }
+    inline iterator end() { detach(); return p->array + d->size; }
+    inline const_iterator end() const { return p->array + d->size; }
+    inline const_iterator constEnd() const { return p->array + d->size; }
+    iterator insert(iterator before, int n, const T &x);
+    inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); }
+    iterator erase(iterator begin, iterator end);
+    inline iterator erase(iterator pos) { return erase(pos, pos+1); }
+
+
+    inline int count() const { return d->size; }
+    inline T& first() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",246) : qt_noop()); return *begin(); }
+    inline const T &first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",247) : qt_noop()); return *begin(); }
+    inline T& last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",248) : qt_noop()); return *(end()-1); }
+    inline const T &last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",249) : qt_noop()); return *(end()-1); }
+    inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; }
+    inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; }
+    QVector<T> mid(int pos, int length = -1) const;
+
+    T value(int i) const;
+    T value(int i, const T &defaultValue) const;
+
+
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef ptrdiff_t difference_type;
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    typedef int size_type;
+    inline void push_back(const T &t) { append(t); }
+    inline void push_front(const T &t) { prepend(t); }
+    void pop_back() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",269) : qt_noop()); erase(end()-1); }
+    void pop_front() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qvector.h",270) : qt_noop()); erase(begin()); }
+    inline bool empty() const
+    { return d->size == 0; }
+    inline T& front() { return first(); }
+    inline const_reference front() const { return first(); }
+    inline reference back() { return last(); }
+    inline const_reference back() const { return last(); }
+
+
+    QVector<T> &operator+=(const QVector<T> &l);
+    inline QVector<T> operator+(const QVector<T> &l) const
+    { QVector n = *this; n += l; return n; }
+    inline QVector<T> &operator+=(const T &t)
+    { append(t); return *this; }
+    inline QVector<T> &operator<< (const T &t)
+    { append(t); return *this; }
+    inline QVector<T> &operator<<(const QVector<T> &l)
+    { *this += l; return *this; }
+
+    QList<T> toList() const;
+
+    static QVector<T> fromList(const QList<T> &list);
+
+
+    static inline QVector<T> fromStdVector(const std::vector<T> &vector)
+    { QVector<T> tmp; qCopy(vector.begin(), vector.end(), std::back_inserter(tmp)); return tmp; }
+    inline std::vector<T> toStdVector() const
+    { std::vector<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; }
+
+
+private:
+    friend class QRegion;
+
+    void detach_helper();
+    QVectorData *malloc(int alloc);
+    void realloc(int size, int alloc);
+    void free(Data *d);
+    int sizeOfTypedData() {
+
+
+        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
+    }
+    inline int alignOfTypedData() const
+    {
+
+        return qMax<int>(sizeof(void*), __alignof__(Data));
+
+
+
+    }
+};
+
+template <typename T>
+void QVector<T>::detach_helper()
+{ realloc(d->size, d->alloc); }
+template <typename T>
+void QVector<T>::reserve(int asize)
+{ if (asize > d->alloc) realloc(d->size, asize); if (d->ref == 1) d->capacity = 1; }
+template <typename T>
+void QVector<T>::resize(int asize)
+{ realloc(asize, (asize > d->alloc || (!d->capacity && asize < d->size && asize < (d->alloc >> 1))) ?
+          QVectorData::grow(sizeOfTypedData(), asize, sizeof(T), QTypeInfo<T>::isStatic)
+          : d->alloc); }
+template <typename T>
+inline void QVector<T>::clear()
+{ *this = QVector<T>(); }
+template <typename T>
+inline const T &QVector<T>::at(int i) const
+{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::at", "index out of range","/usr/include/qt4/QtCore/qvector.h",338) : qt_noop());
+  return p->array[i]; }
+template <typename T>
+inline const T &QVector<T>::operator[](int i) const
+{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qvector.h",342) : qt_noop());
+  return p->array[i]; }
+template <typename T>
+inline T &QVector<T>::operator[](int i)
+{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::operator[]", "index out of range","/usr/include/qt4/QtCore/qvector.h",346) : qt_noop());
+  return data()[i]; }
+template <typename T>
+inline void QVector<T>::insert(int i, const T &t)
+{ ((!(i >= 0 && i <= d->size)) ? qt_assert_x("QVector<T>::insert", "index out of range","/usr/include/qt4/QtCore/qvector.h",350) : qt_noop());
+  insert(begin() + i, 1, t); }
+template <typename T>
+inline void QVector<T>::insert(int i, int n, const T &t)
+{ ((!(i >= 0 && i <= d->size)) ? qt_assert_x("QVector<T>::insert", "index out of range","/usr/include/qt4/QtCore/qvector.h",354) : qt_noop());
+  insert(begin() + i, n, t); }
+template <typename T>
+inline void QVector<T>::remove(int i, int n)
+{ ((!(i >= 0 && n >= 0 && i + n <= d->size)) ? qt_assert_x("QVector<T>::remove", "index out of range","/usr/include/qt4/QtCore/qvector.h",358) : qt_noop());
+  erase(begin() + i, begin() + i + n); }
+template <typename T>
+inline void QVector<T>::remove(int i)
+{ ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::remove", "index out of range","/usr/include/qt4/QtCore/qvector.h",362) : qt_noop());
+  erase(begin() + i, begin() + i + 1); }
+template <typename T>
+inline void QVector<T>::prepend(const T &t)
+{ insert(begin(), 1, t); }
+
+template <typename T>
+inline void QVector<T>::replace(int i, const T &t)
+{
+    ((!(i >= 0 && i < d->size)) ? qt_assert_x("QVector<T>::replace", "index out of range","/usr/include/qt4/QtCore/qvector.h",371) : qt_noop());
+    const T copy(t);
+    data()[i] = copy;
+}
+
+template <typename T>
+QVector<T> &QVector<T>::operator=(const QVector<T> &v)
+{
+    v.d->ref.ref();
+    if (!d->ref.deref())
+        free(p);
+    d = v.d;
+    if (!d->sharable)
+        detach_helper();
+    return *this;
+}
+
+template <typename T>
+inline QVectorData *QVector<T>::malloc(int aalloc)
+{
+    QVectorData *vectordata = QVectorData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
+    do { if (!(vectordata)) qBadAlloc(); } while (0);
+    return vectordata;
+}
+
+template <typename T>
+QVector<T>::QVector(int asize)
+{
+    d = malloc(asize);
+    d->ref = 1;
+    d->alloc = d->size = asize;
+    d->sharable = true;
+    d->capacity = false;
+    if (QTypeInfo<T>::isComplex) {
+        T* b = p->array;
+        T* i = p->array + d->size;
+        while (i != b)
+            new (--i) T;
+    } else {
+        qMemSet(p->array, 0, asize * sizeof(T));
+    }
+}
+
+template <typename T>
+QVector<T>::QVector(int asize, const T &t)
+{
+    d = malloc(asize);
+    d->ref = 1;
+    d->alloc = d->size = asize;
+    d->sharable = true;
+    d->capacity = false;
+    T* i = p->array + d->size;
+    while (i != p->array)
+        new (--i) T(t);
+}
+
+template <typename T>
+void QVector<T>::free(Data *x)
+{
+    if (QTypeInfo<T>::isComplex) {
+        T* b = x->array;
+        union { QVectorData *d; Data *p; } u;
+        u.p = x;
+        T* i = b + u.d->size;
+        while (i-- != b)
+             i->~T();
+    }
+    x->free(x, alignOfTypedData());
+}
+
+template <typename T>
+void QVector<T>::realloc(int asize, int aalloc)
+{
+    ((!(asize <= aalloc)) ? qt_assert("asize <= aalloc","/usr/include/qt4/QtCore/qvector.h",444) : qt_noop());
+    T *pOld;
+    T *pNew;
+    union { QVectorData *d; Data *p; } x;
+    x.d = d;
+
+    if (QTypeInfo<T>::isComplex && asize < d->size && d->ref == 1 ) {
+
+
+        pOld = p->array + d->size;
+        pNew = p->array + asize;
+        while (asize < d->size) {
+            (--pOld)->~T();
+            d->size--;
+        }
+    }
+
+    if (aalloc != d->alloc || d->ref != 1) {
+
+        if (QTypeInfo<T>::isStatic) {
+            x.d = malloc(aalloc);
+            do { if (!(x.p)) qBadAlloc(); } while (0);
+            x.d->size = 0;
+        } else if (d->ref != 1) {
+            x.d = malloc(aalloc);
+            do { if (!(x.p)) qBadAlloc(); } while (0);
+            if (QTypeInfo<T>::isComplex) {
+                x.d->size = 0;
+            } else {
+                ::memcpy(x.p, p, sizeOfTypedData() + (qMin(aalloc, d->alloc) - 1) * sizeof(T));
+                x.d->size = d->size;
+            }
+        } else {
+            try {
+                QVectorData *mem = QVectorData::reallocate(d, sizeOfTypedData() + (aalloc - 1) * sizeof(T),
+                                                           sizeOfTypedData() + (d->alloc - 1) * sizeof(T), alignOfTypedData());
+                do { if (!(mem)) qBadAlloc(); } while (0);
+                x.d = d = mem;
+                x.d->size = d->size;
+            } catch (const std::bad_alloc &) {
+                if (aalloc > d->alloc)
+                    throw;
+            }
+        }
+        x.d->ref = 1;
+        x.d->alloc = aalloc;
+        x.d->sharable = true;
+        x.d->capacity = d->capacity;
+        x.d->reserved = 0;
+    }
+
+    if (QTypeInfo<T>::isComplex) {
+        try {
+            pOld = p->array + x.d->size;
+            pNew = x.p->array + x.d->size;
+
+            const int toMove = qMin(asize, d->size);
+            while (x.d->size < toMove) {
+                new (pNew++) T(*pOld++);
+                x.d->size++;
+            }
+
+            while (x.d->size < asize) {
+                new (pNew++) T;
+                x.d->size++;
+            }
+        } catch (...) {
+            free(x.p);
+            throw;
+        }
+
+    } else if (asize > x.d->size) {
+
+        qMemSet(x.p->array + x.d->size, 0, (asize - x.d->size) * sizeof(T));
+    }
+    x.d->size = asize;
+
+    if (d != x.d) {
+        if (!d->ref.deref())
+            free(p);
+        d = x.d;
+    }
+}
+
+template<typename T>
+ T QVector<T>::value(int i) const
+{
+    if (i < 0 || i >= d->size) {
+        return T();
+    }
+    return p->array[i];
+}
+template<typename T>
+ T QVector<T>::value(int i, const T &defaultValue) const
+{
+    return ((i < 0 || i >= d->size) ? defaultValue : p->array[i]);
+}
+
+template <typename T>
+void QVector<T>::append(const T &t)
+{
+    if (d->ref != 1 || d->size + 1 > d->alloc) {
+        const T copy(t);
+        realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T),
+                                           QTypeInfo<T>::isStatic));
+        if (QTypeInfo<T>::isComplex)
+            new (p->array + d->size) T(copy);
+        else
+            p->array[d->size] = copy;
+    } else {
+        if (QTypeInfo<T>::isComplex)
+            new (p->array + d->size) T(t);
+        else
+            p->array[d->size] = t;
+    }
+    ++d->size;
+}
+
+template <typename T>
+typename QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t)
+{
+    int offset = int(before - p->array);
+    if (n != 0) {
+        const T copy(t);
+        if (d->ref != 1 || d->size + n > d->alloc)
+            realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + n, sizeof(T),
+                                               QTypeInfo<T>::isStatic));
+        if (QTypeInfo<T>::isStatic) {
+            T *b = p->array + d->size;
+            T *i = p->array + d->size + n;
+            while (i != b)
+                new (--i) T;
+            i = p->array + d->size;
+            T *j = i + n;
+            b = p->array + offset;
+            while (i != b)
+                *--j = *--i;
+            i = b+n;
+            while (i != b)
+                *--i = copy;
+        } else {
+            T *b = p->array + offset;
+            T *i = b + n;
+            memmove(i, b, (d->size - offset) * sizeof(T));
+            while (i != b)
+                new (--i) T(copy);
+        }
+        d->size += n;
+    }
+    return p->array + offset;
+}
+
+template <typename T>
+typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend)
+{
+    int f = int(abegin - p->array);
+    int l = int(aend - p->array);
+    int n = l - f;
+    detach();
+    if (QTypeInfo<T>::isComplex) {
+        qCopy(p->array+l, p->array+d->size, p->array+f);
+        T *i = p->array+d->size;
+        T* b = p->array+d->size-n;
+        while (i != b) {
+            --i;
+            i->~T();
+        }
+    } else {
+        memmove(p->array + f, p->array + l, (d->size-l)*sizeof(T));
+    }
+    d->size -= n;
+    return p->array + f;
+}
+
+template <typename T>
+bool QVector<T>::operator==(const QVector<T> &v) const
+{
+    if (d->size != v.d->size)
+        return false;
+    if (d == v.d)
+        return true;
+    T* b = p->array;
+    T* i = b + d->size;
+    T* j = v.p->array + d->size;
+    while (i != b)
+        if (!(*--i == *--j))
+            return false;
+    return true;
+}
+
+template <typename T>
+QVector<T> &QVector<T>::fill(const T &from, int asize)
+{
+    const T copy(from);
+    resize(asize < 0 ? d->size : asize);
+    if (d->size) {
+        T *i = p->array + d->size;
+        T *b = p->array;
+        while (i != b)
+            *--i = copy;
+    }
+    return *this;
+}
+
+template <typename T>
+QVector<T> &QVector<T>::operator+=(const QVector &l)
+{
+    int newSize = d->size + l.d->size;
+    realloc(d->size, newSize);
+
+    T *w = p->array + newSize;
+    T *i = l.p->array + l.d->size;
+    T *b = l.p->array;
+    while (i != b) {
+        if (QTypeInfo<T>::isComplex)
+            new (--w) T(*--i);
+        else
+            *--w = *--i;
+    }
+    d->size = newSize;
+    return *this;
+}
+
+template <typename T>
+int QVector<T>::indexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from = qMax(from + d->size, 0);
+    if (from < d->size) {
+        T* n = p->array + from - 1;
+        T* e = p->array + d->size;
+        while (++n != e)
+            if (*n == t)
+                return n - p->array;
+    }
+    return -1;
+}
+
+template <typename T>
+int QVector<T>::lastIndexOf(const T &t, int from) const
+{
+    if (from < 0)
+        from += d->size;
+    else if (from >= d->size)
+        from = d->size-1;
+    if (from >= 0) {
+        T* b = p->array;
+        T* n = p->array + from + 1;
+        while (n != b) {
+            if (*--n == t)
+                return n - b;
+        }
+    }
+    return -1;
+}
+
+template <typename T>
+bool QVector<T>::contains(const T &t) const
+{
+    T* b = p->array;
+    T* i = p->array + d->size;
+    while (i != b)
+        if (*--i == t)
+            return true;
+    return false;
+}
+
+template <typename T>
+int QVector<T>::count(const T &t) const
+{
+    int c = 0;
+    T* b = p->array;
+    T* i = p->array + d->size;
+    while (i != b)
+        if (*--i == t)
+            ++c;
+    return c;
+}
+
+template <typename T>
+ QVector<T> QVector<T>::mid(int pos, int length) const
+{
+    if (length < 0)
+        length = size() - pos;
+    if (pos == 0 && length == size())
+        return *this;
+    QVector<T> copy;
+    if (pos + length > size())
+        length = size() - pos;
+    for (int i = pos; i < pos + length; ++i)
+        copy += at(i);
+    return copy;
+}
+
+template <typename T>
+ QList<T> QVector<T>::toList() const
+{
+    QList<T> result;
+    for (int i = 0; i < size(); ++i)
+        result.append(at(i));
+    return result;
+}
+
+template <typename T>
+ QVector<T> QList<T>::toVector() const
+{
+    QVector<T> result(size());
+    for (int i = 0; i < size(); ++i)
+        result[i] = at(i);
+    return result;
+}
+
+template <typename T>
+QVector<T> QVector<T>::fromList(const QList<T> &list)
+{
+    return list.toVector();
+}
+
+template <typename T>
+QList<T> QList<T>::fromVector(const QVector<T> &vector)
+{
+    return vector.toList();
+}
+
+template <class T> class QVectorIterator { typedef typename QVector<T>::const_iterator const_iterator; QVector<T> c; const_iterator i; public: inline QVectorIterator(const QVector<T> &container) : c(container), i(c.constBegin()) {} inline QVectorIterator &operator=(const QVector<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+template <class T> class QMutableVectorIterator { typedef typename QVector<T>::iterator iterator; typedef typename QVector<T>::const_iterator const_iterator; QVector<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableVectorIterator(QVector<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableVectorIterator() { c->setSharable(true); } inline QMutableVectorIterator &operator=(QVector<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qvector.h",769) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qvector.h",769) : qt_noop()); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+# 796 "/usr/include/qt4/QtCore/qvector.h"
+
+
+
+# 46 "/usr/include/qt4/QtGui/qpolygon.h" 2
+
+
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QMatrix;
+class QTransform;
+class QRect;
+class QVariant;
+
+class QPolygon : public QVector<QPoint>
+{
+public:
+    inline QPolygon() {}
+    inline ~QPolygon() {}
+    inline QPolygon(int size);
+    inline QPolygon(const QPolygon &a) : QVector<QPoint>(a) {}
+    inline QPolygon(const QVector<QPoint> &v) : QVector<QPoint>(v) {}
+    QPolygon(const QRect &r, bool closed=false);
+    QPolygon(int nPoints, const int *points);
+    operator QVariant() const;
+
+    void translate(int dx, int dy);
+    void translate(const QPoint &offset);
+
+    QPolygon translated(int dx, int dy) const;
+    inline QPolygon translated(const QPoint &offset) const;
+
+    QRect boundingRect() const;
+
+    void point(int i, int *x, int *y) const;
+    QPoint point(int i) const;
+    void setPoint(int index, int x, int y);
+    void setPoint(int index, const QPoint &p);
+    void setPoints(int nPoints, const int *points);
+    void setPoints(int nPoints, int firstx, int firsty, ...);
+    void putPoints(int index, int nPoints, const int *points);
+    void putPoints(int index, int nPoints, int firstx, int firsty, ...);
+    void putPoints(int index, int nPoints, const QPolygon & from, int fromIndex=0);
+
+    bool containsPoint(const QPoint &pt, Qt::FillRule fillRule) const;
+
+    QPolygon united(const QPolygon &r) const;
+    QPolygon intersected(const QPolygon &r) const;
+    QPolygon subtracted(const QPolygon &r) const;
+};
+
+inline QPolygon::QPolygon(int asize) : QVector<QPoint>(asize) {}
+
+
+ QDebug operator<<(QDebug, const QPolygon &);
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon);
+ QDataStream &operator>>(QDataStream &stream, QPolygon &polygon);
+
+
+
+
+
+
+inline void QPolygon::setPoint(int index, const QPoint &pt)
+{ (*this)[index] = pt; }
+
+inline void QPolygon::setPoint(int index, int x, int y)
+{ (*this)[index] = QPoint(x, y); }
+
+inline QPoint QPolygon::point(int index) const
+{ return at(index); }
+
+inline void QPolygon::translate(const QPoint &offset)
+{ translate(offset.x(), offset.y()); }
+
+inline QPolygon QPolygon::translated(const QPoint &offset) const
+{ return translated(offset.x(), offset.y()); }
+
+class QRectF;
+
+class QPolygonF : public QVector<QPointF>
+{
+public:
+    inline QPolygonF() {}
+    inline ~QPolygonF() {}
+    inline QPolygonF(int size);
+    inline QPolygonF(const QPolygonF &a) : QVector<QPointF>(a) {}
+    inline QPolygonF(const QVector<QPointF> &v) : QVector<QPointF>(v) {}
+    QPolygonF(const QRectF &r);
+    QPolygonF(const QPolygon &a);
+
+    inline void translate(qreal dx, qreal dy);
+    void translate(const QPointF &offset);
+
+    inline QPolygonF translated(qreal dx, qreal dy) const;
+    QPolygonF translated(const QPointF &offset) const;
+
+    QPolygon toPolygon() const;
+
+    bool isClosed() const { return !isEmpty() && first() == last(); }
+
+    QRectF boundingRect() const;
+
+    bool containsPoint(const QPointF &pt, Qt::FillRule fillRule) const;
+
+    QPolygonF united(const QPolygonF &r) const;
+    QPolygonF intersected(const QPolygonF &r) const;
+    QPolygonF subtracted(const QPolygonF &r) const;
+};
+
+inline QPolygonF::QPolygonF(int asize) : QVector<QPointF>(asize) {}
+
+
+ QDebug operator<<(QDebug, const QPolygonF &);
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &stream, const QPolygonF &array);
+ QDataStream &operator>>(QDataStream &stream, QPolygonF &array);
+
+
+inline void QPolygonF::translate(qreal dx, qreal dy)
+{ translate(QPointF(dx, dy)); }
+
+inline QPolygonF QPolygonF::translated(qreal dx, qreal dy) const
+{ return translated(QPointF(dx, dy)); }
+
+
+
+
+# 46 "/usr/include/qt4/QtGui/qmatrix.h" 2
+# 1 "/usr/include/qt4/QtGui/qregion.h" 1
+# 53 "/usr/include/qt4/QtGui/qregion.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+template <class T> class QVector;
+class QVariant;
+
+
+struct QRegionPrivate;
+
+
+class QBitmap;
+
+class QRegion
+{
+public:
+    enum RegionType { Rectangle, Ellipse };
+
+    QRegion();
+    QRegion(int x, int y, int w, int h, RegionType t = Rectangle);
+    QRegion(const QRect &r, RegionType t = Rectangle);
+    QRegion(const QPolygon &pa, Qt::FillRule fillRule = Qt::OddEvenFill);
+
+
+
+    QRegion(const QRegion &region);
+    QRegion(const QBitmap &bitmap);
+    ~QRegion();
+    QRegion &operator=(const QRegion &);
+
+
+
+
+    bool isEmpty() const;
+
+    bool contains(const QPoint &p) const;
+    bool contains(const QRect &r) const;
+
+    void translate(int dx, int dy);
+    inline void translate(const QPoint &p) { translate(p.x(), p.y()); }
+    QRegion translated(int dx, int dy) const;
+    inline QRegion translated(const QPoint &p) const { return translated(p.x(), p.y()); }
+
+
+    QRegion unite(const QRegion &r) const;
+    QRegion unite(const QRect &r) const;
+    QRegion intersect(const QRegion &r) const;
+    QRegion intersect(const QRect &r) const;
+    QRegion subtract(const QRegion &r) const;
+    QRegion eor(const QRegion &r) const;
+
+    inline QRegion united(const QRegion &r) const { return unite(r); }
+    inline QRegion united(const QRect &r) const { return unite(r); }
+    inline QRegion intersected(const QRegion &r) const { return intersect(r); }
+    inline QRegion intersected(const QRect &r) const { return intersect(r); }
+    inline QRegion subtracted(const QRegion &r) const { return subtract(r); }
+    inline QRegion xored(const QRegion &r) const { return eor(r); }
+
+    bool intersects(const QRegion &r) const;
+    bool intersects(const QRect &r) const;
+
+    QRect boundingRect() const;
+    QVector<QRect> rects() const;
+    void setRects(const QRect *rect, int num);
+
+    int numRects() const;
+
+    int rectCount() const;
+
+    const QRegion operator|(const QRegion &r) const;
+    const QRegion operator+(const QRegion &r) const;
+    const QRegion operator+(const QRect &r) const;
+    const QRegion operator&(const QRegion &r) const;
+    const QRegion operator&(const QRect &r) const;
+    const QRegion operator-(const QRegion &r) const;
+    const QRegion operator^(const QRegion &r) const;
+    QRegion& operator|=(const QRegion &r);
+    QRegion& operator+=(const QRegion &r);
+    QRegion& operator+=(const QRect &r);
+    QRegion& operator&=(const QRegion &r);
+    QRegion& operator&=(const QRect &r);
+    QRegion& operator-=(const QRegion &r);
+    QRegion& operator^=(const QRegion &r);
+
+    bool operator==(const QRegion &r) const;
+    inline bool operator!=(const QRegion &r) const { return !(operator==(r)); }
+    operator QVariant() const;
+# 150 "/usr/include/qt4/QtGui/qregion.h"
+    inline Region handle() const { if(!d->rgn) updateX11Region(); return d->rgn; }
+# 172 "/usr/include/qt4/QtGui/qregion.h"
+    friend QDataStream &operator<<(QDataStream &, const QRegion &);
+    friend QDataStream &operator>>(QDataStream &, QRegion &);
+
+private:
+    QRegion copy() const;
+    void detach();
+
+
+
+
+    void updateX11Region() const;
+    void *clipRectangles(int &num) const;
+    friend void *qt_getClipRects(const QRegion &r, int &num);
+
+
+
+
+    friend bool qt_region_strictContains(const QRegion &region,
+                                         const QRect &rect);
+    friend struct QRegionPrivate;
+
+
+    void exec(const QByteArray &ba, int ver = 0, QDataStream::ByteOrder byteOrder = QDataStream::BigEndian);
+
+    struct QRegionData {
+        QBasicAtomicInt ref;
+
+
+
+        Region rgn;
+        void *xrectangles;
+
+
+
+
+        QRegionPrivate *qt_rgn;
+
+    };
+
+
+
+    struct QRegionData *d;
+    static struct QRegionData shared_empty;
+    static void cleanUp(QRegionData *x);
+};
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QRegion &);
+ QDataStream &operator>>(QDataStream &, QRegion &);
+
+
+
+ QDebug operator<<(QDebug, const QRegion &);
+
+
+
+
+
+# 47 "/usr/include/qt4/QtGui/qmatrix.h" 2
+
+# 1 "/usr/include/qt4/QtCore/qline.h" 1
+# 47 "/usr/include/qt4/QtCore/qline.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+
+
+
+
+class QLine
+{
+public:
+    inline QLine();
+    inline QLine(const QPoint &pt1, const QPoint &pt2);
+    inline QLine(int x1, int y1, int x2, int y2);
+
+    inline bool isNull() const;
+
+    inline QPoint p1() const;
+    inline QPoint p2() const;
+
+    inline int x1() const;
+    inline int y1() const;
+
+    inline int x2() const;
+    inline int y2() const;
+
+    inline int dx() const;
+    inline int dy() const;
+
+    inline void translate(const QPoint &p);
+    inline void translate(int dx, int dy);
+
+    inline QLine translated(const QPoint &p) const;
+    inline QLine translated(int dx, int dy) const;
+
+    inline void setP1(const QPoint &p1);
+    inline void setP2(const QPoint &p2);
+    inline void setPoints(const QPoint &p1, const QPoint &p2);
+    inline void setLine(int x1, int y1, int x2, int y2);
+
+    inline bool operator==(const QLine &d) const;
+    inline bool operator!=(const QLine &d) const { return !(*this == d); }
+
+private:
+    QPoint pt1, pt2;
+};
+template <> class QTypeInfo<QLine > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLine)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLine"; } };
+
+
+
+
+
+inline QLine::QLine() { }
+
+inline QLine::QLine(const QPoint &pt1_, const QPoint &pt2_) : pt1(pt1_), pt2(pt2_) { }
+
+inline QLine::QLine(int x1pos, int y1pos, int x2pos, int y2pos) : pt1(QPoint(x1pos, y1pos)), pt2(QPoint(x2pos, y2pos)) { }
+
+inline bool QLine::isNull() const
+{
+    return pt1 == pt2;
+}
+
+inline int QLine::x1() const
+{
+    return pt1.x();
+}
+
+inline int QLine::y1() const
+{
+    return pt1.y();
+}
+
+inline int QLine::x2() const
+{
+    return pt2.x();
+}
+
+inline int QLine::y2() const
+{
+    return pt2.y();
+}
+
+inline QPoint QLine::p1() const
+{
+    return pt1;
+}
+
+inline QPoint QLine::p2() const
+{
+    return pt2;
+}
+
+inline int QLine::dx() const
+{
+    return pt2.x() - pt1.x();
+}
+
+inline int QLine::dy() const
+{
+    return pt2.y() - pt1.y();
+}
+
+inline void QLine::translate(const QPoint &point)
+{
+    pt1 += point;
+    pt2 += point;
+}
+
+inline void QLine::translate(int adx, int ady)
+{
+    this->translate(QPoint(adx, ady));
+}
+
+inline QLine QLine::translated(const QPoint &p) const
+{
+    return QLine(pt1 + p, pt2 + p);
+}
+
+inline QLine QLine::translated(int adx, int ady) const
+{
+    return translated(QPoint(adx, ady));
+}
+
+inline void QLine::setP1(const QPoint &aP1)
+{
+    pt1 = aP1;
+}
+
+inline void QLine::setP2(const QPoint &aP2)
+{
+    pt2 = aP2;
+}
+
+inline void QLine::setPoints(const QPoint &aP1, const QPoint &aP2)
+{
+    pt1 = aP1;
+    pt2 = aP2;
+}
+
+inline void QLine::setLine(int aX1, int aY1, int aX2, int aY2)
+{
+    pt1 = QPoint(aX1, aY1);
+    pt2 = QPoint(aX2, aY2);
+}
+
+inline bool QLine::operator==(const QLine &d) const
+{
+    return pt1 == d.pt1 && pt2 == d.pt2;
+}
+
+
+ QDebug operator<<(QDebug d, const QLine &p);
+
+
+
+ QDataStream &operator<<(QDataStream &, const QLine &);
+ QDataStream &operator>>(QDataStream &, QLine &);
+
+
+
+
+
+class QLineF {
+public:
+
+    enum IntersectType { NoIntersection, BoundedIntersection, UnboundedIntersection };
+
+    inline QLineF();
+    inline QLineF(const QPointF &pt1, const QPointF &pt2);
+    inline QLineF(qreal x1, qreal y1, qreal x2, qreal y2);
+    inline QLineF(const QLine &line) : pt1(line.p1()), pt2(line.p2()) { }
+
+    static QLineF fromPolar(qreal length, qreal angle);
+
+    bool isNull() const;
+
+    inline QPointF p1() const;
+    inline QPointF p2() const;
+
+    inline qreal x1() const;
+    inline qreal y1() const;
+
+    inline qreal x2() const;
+    inline qreal y2() const;
+
+    inline qreal dx() const;
+    inline qreal dy() const;
+
+    qreal length() const;
+    void setLength(qreal len);
+
+    qreal angle() const;
+    void setAngle(qreal angle);
+
+    qreal angleTo(const QLineF &l) const;
+
+    QLineF unitVector() const;
+    QLineF normalVector() const;
+
+
+    IntersectType intersect(const QLineF &l, QPointF *intersectionPoint) const;
+
+    qreal angle(const QLineF &l) const;
+
+    QPointF pointAt(qreal t) const;
+    inline void translate(const QPointF &p);
+    inline void translate(qreal dx, qreal dy);
+
+    inline QLineF translated(const QPointF &p) const;
+    inline QLineF translated(qreal dx, qreal dy) const;
+
+    inline void setP1(const QPointF &p1);
+    inline void setP2(const QPointF &p2);
+    inline void setPoints(const QPointF &p1, const QPointF &p2);
+    inline void setLine(qreal x1, qreal y1, qreal x2, qreal y2);
+
+    inline bool operator==(const QLineF &d) const;
+    inline bool operator!=(const QLineF &d) const { return !(*this == d); }
+
+    QLine toLine() const;
+
+private:
+    QPointF pt1, pt2;
+};
+template <> class QTypeInfo<QLineF > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLineF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLineF"; } };
+
+
+
+
+
+inline QLineF::QLineF()
+{
+}
+
+inline QLineF::QLineF(const QPointF &apt1, const QPointF &apt2)
+    : pt1(apt1), pt2(apt2)
+{
+}
+
+inline QLineF::QLineF(qreal x1pos, qreal y1pos, qreal x2pos, qreal y2pos)
+    : pt1(x1pos, y1pos), pt2(x2pos, y2pos)
+{
+}
+
+inline qreal QLineF::x1() const
+{
+    return pt1.x();
+}
+
+inline qreal QLineF::y1() const
+{
+    return pt1.y();
+}
+
+inline qreal QLineF::x2() const
+{
+    return pt2.x();
+}
+
+inline qreal QLineF::y2() const
+{
+    return pt2.y();
+}
+
+inline QPointF QLineF::p1() const
+{
+    return pt1;
+}
+
+inline QPointF QLineF::p2() const
+{
+    return pt2;
+}
+
+inline qreal QLineF::dx() const
+{
+    return pt2.x() - pt1.x();
+}
+
+inline qreal QLineF::dy() const
+{
+    return pt2.y() - pt1.y();
+}
+
+inline QLineF QLineF::normalVector() const
+{
+    return QLineF(p1(), p1() + QPointF(dy(), -dx()));
+}
+
+inline void QLineF::translate(const QPointF &point)
+{
+    pt1 += point;
+    pt2 += point;
+}
+
+inline void QLineF::translate(qreal adx, qreal ady)
+{
+    this->translate(QPointF(adx, ady));
+}
+
+inline QLineF QLineF::translated(const QPointF &p) const
+{
+    return QLineF(pt1 + p, pt2 + p);
+}
+
+inline QLineF QLineF::translated(qreal adx, qreal ady) const
+{
+    return translated(QPointF(adx, ady));
+}
+
+inline void QLineF::setLength(qreal len)
+{
+    if (isNull())
+        return;
+    QLineF v = unitVector();
+    pt2 = QPointF(pt1.x() + v.dx() * len, pt1.y() + v.dy() * len);
+}
+
+inline QPointF QLineF::pointAt(qreal t) const
+{
+    qreal vx = pt2.x() - pt1.x();
+    qreal vy = pt2.y() - pt1.y();
+    return QPointF(pt1.x() + vx * t, pt1.y() + vy * t);
+}
+
+inline QLine QLineF::toLine() const
+{
+    return QLine(pt1.toPoint(), pt2.toPoint());
+}
+
+
+inline void QLineF::setP1(const QPointF &aP1)
+{
+    pt1 = aP1;
+}
+
+inline void QLineF::setP2(const QPointF &aP2)
+{
+    pt2 = aP2;
+}
+
+inline void QLineF::setPoints(const QPointF &aP1, const QPointF &aP2)
+{
+    pt1 = aP1;
+    pt2 = aP2;
+}
+
+inline void QLineF::setLine(qreal aX1, qreal aY1, qreal aX2, qreal aY2)
+{
+    pt1 = QPointF(aX1, aY1);
+    pt2 = QPointF(aX2, aY2);
+}
+
+
+inline bool QLineF::operator==(const QLineF &d) const
+{
+    return pt1 == d.pt1 && pt2 == d.pt2;
+}
+
+
+
+
+ QDebug operator<<(QDebug d, const QLineF &p);
+
+
+
+ QDataStream &operator<<(QDataStream &, const QLineF &);
+ QDataStream &operator>>(QDataStream &, QLineF &);
+
+
+
+
+
+# 49 "/usr/include/qt4/QtGui/qmatrix.h" 2
+
+
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QPainterPath;
+class QVariant;
+
+class QMatrix
+{
+public:
+    inline explicit QMatrix(Qt::Initialization) {}
+    QMatrix();
+    QMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
+            qreal dx, qreal dy);
+    QMatrix(const QMatrix &matrix);
+
+    void setMatrix(qreal m11, qreal m12, qreal m21, qreal m22,
+                   qreal dx, qreal dy);
+
+    qreal m11() const { return _m11; }
+    qreal m12() const { return _m12; }
+    qreal m21() const { return _m21; }
+    qreal m22() const { return _m22; }
+    qreal dx() const { return _dx; }
+    qreal dy() const { return _dy; }
+
+    void map(int x, int y, int *tx, int *ty) const;
+    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;
+    QRect mapRect(const QRect &) const;
+    QRectF mapRect(const QRectF &) const;
+
+    QPoint map(const QPoint &p) const;
+    QPointF map(const QPointF&p) const;
+    QLine map(const QLine &l) const;
+    QLineF map(const QLineF &l) const;
+    QPolygonF map(const QPolygonF &a) const;
+    QPolygon map(const QPolygon &a) const;
+    QRegion map(const QRegion &r) const;
+    QPainterPath map(const QPainterPath &p) const;
+    QPolygon mapToPolygon(const QRect &r) const;
+
+    void reset();
+    inline bool isIdentity() const;
+
+    QMatrix &translate(qreal dx, qreal dy);
+    QMatrix &scale(qreal sx, qreal sy);
+    QMatrix &shear(qreal sh, qreal sv);
+    QMatrix &rotate(qreal a);
+
+    bool isInvertible() const { return !qFuzzyIsNull(_m11*_m22 - _m12*_m21); }
+    qreal determinant() const { return _m11*_m22 - _m12*_m21; }
+
+    qreal det() const { return _m11*_m22 - _m12*_m21; }
+
+
+    QMatrix inverted(bool *invertible = 0) const;
+
+    bool operator==(const QMatrix &) const;
+    bool operator!=(const QMatrix &) const;
+
+    QMatrix &operator*=(const QMatrix &);
+    QMatrix operator*(const QMatrix &o) const;
+
+    QMatrix &operator=(const QMatrix &);
+
+    operator QVariant() const;
+
+
+
+
+
+
+
+private:
+    inline QMatrix(bool)
+            : _m11(1.)
+            , _m12(0.)
+            , _m21(0.)
+            , _m22(1.)
+            , _dx(0.)
+            , _dy(0.) {}
+    inline QMatrix(qreal am11, qreal am12, qreal am21, qreal am22, qreal adx, qreal ady, bool)
+            : _m11(am11)
+            , _m12(am12)
+            , _m21(am21)
+            , _m22(am22)
+            , _dx(adx)
+            , _dy(ady) {}
+    friend class QTransform;
+    qreal _m11, _m12;
+    qreal _m21, _m22;
+    qreal _dx, _dy;
+};
+template <> class QTypeInfo<QMatrix > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMatrix)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMatrix"; } };
+
+
+ inline QPoint operator*(const QPoint &p, const QMatrix &m)
+{ return m.map(p); }
+ inline QPointF operator*(const QPointF &p, const QMatrix &m)
+{ return m.map(p); }
+ inline QLineF operator*(const QLineF &l, const QMatrix &m)
+{ return m.map(l); }
+ inline QLine operator*(const QLine &l, const QMatrix &m)
+{ return m.map(l); }
+ inline QPolygon operator *(const QPolygon &a, const QMatrix &m)
+{ return m.map(a); }
+ inline QPolygonF operator *(const QPolygonF &a, const QMatrix &m)
+{ return m.map(a); }
+ inline QRegion operator *(const QRegion &r, const QMatrix &m)
+{ return m.map(r); }
+ QPainterPath operator *(const QPainterPath &p, const QMatrix &m);
+
+inline bool QMatrix::isIdentity() const
+{
+    return qFuzzyIsNull(_m11 - 1) && qFuzzyIsNull(_m22 - 1) && qFuzzyIsNull(_m12)
+           && qFuzzyIsNull(_m21) && qFuzzyIsNull(_dx) && qFuzzyIsNull(_dy);
+}
+
+inline bool qFuzzyCompare(const QMatrix& m1, const QMatrix& m2)
+{
+    return qFuzzyCompare(m1.m11(), m2.m11())
+        && qFuzzyCompare(m1.m12(), m2.m12())
+        && qFuzzyCompare(m1.m21(), m2.m21())
+        && qFuzzyCompare(m1.m22(), m2.m22())
+        && qFuzzyCompare(m1.dx(), m2.dx())
+        && qFuzzyCompare(m1.dy(), m2.dy());
+}
+
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QMatrix &);
+ QDataStream &operator>>(QDataStream &, QMatrix &);
+
+
+
+ QDebug operator<<(QDebug, const QMatrix &);
+# 202 "/usr/include/qt4/QtGui/qmatrix.h"
+
+
+
+# 45 "/usr/include/qt4/QtGui/qtransform.h" 2
+# 1 "/usr/include/qt4/QtGui/qpainterpath.h" 1
+# 52 "/usr/include/qt4/QtGui/qpainterpath.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QFont;
+class QPainterPathPrivate;
+struct QPainterPathPrivateDeleter;
+class QPainterPathData;
+class QPainterPathStrokerPrivate;
+class QPolygonF;
+class QRegion;
+class QVectorPath;
+
+class QPainterPath
+{
+public:
+    enum ElementType {
+        MoveToElement,
+        LineToElement,
+        CurveToElement,
+        CurveToDataElement
+    };
+
+    class Element {
+    public:
+        qreal x;
+        qreal y;
+        ElementType type;
+
+        bool isMoveTo() const { return type == MoveToElement; }
+        bool isLineTo() const { return type == LineToElement; }
+        bool isCurveTo() const { return type == CurveToElement; }
+
+        operator QPointF () const { return QPointF(x, y); }
+
+        bool operator==(const Element &e) const { return qFuzzyCompare(x, e.x)
+            && qFuzzyCompare(y, e.y) && type == e.type; }
+        inline bool operator!=(const Element &e) const { return !operator==(e); }
+    };
+
+    QPainterPath();
+    explicit QPainterPath(const QPointF &startPoint);
+    QPainterPath(const QPainterPath &other);
+    QPainterPath &operator=(const QPainterPath &other);
+    ~QPainterPath();
+
+    void closeSubpath();
+
+    void moveTo(const QPointF &p);
+    inline void moveTo(qreal x, qreal y);
+
+    void lineTo(const QPointF &p);
+    inline void lineTo(qreal x, qreal y);
+
+    void arcMoveTo(const QRectF &rect, qreal angle);
+    inline void arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle);
+
+    void arcTo(const QRectF &rect, qreal startAngle, qreal arcLength);
+    inline void arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength);
+
+    void cubicTo(const QPointF &ctrlPt1, const QPointF &ctrlPt2, const QPointF &endPt);
+    inline void cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
+                        qreal endPtx, qreal endPty);
+    void quadTo(const QPointF &ctrlPt, const QPointF &endPt);
+    inline void quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty);
+
+    QPointF currentPosition() const;
+
+    void addRect(const QRectF &rect);
+    inline void addRect(qreal x, qreal y, qreal w, qreal h);
+    void addEllipse(const QRectF &rect);
+    inline void addEllipse(qreal x, qreal y, qreal w, qreal h);
+    inline void addEllipse(const QPointF &center, qreal rx, qreal ry);
+    void addPolygon(const QPolygonF &polygon);
+    void addText(const QPointF &point, const QFont &f, const QString &text);
+    inline void addText(qreal x, qreal y, const QFont &f, const QString &text);
+    void addPath(const QPainterPath &path);
+    void addRegion(const QRegion &region);
+
+    void addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius,
+                        Qt::SizeMode mode = Qt::AbsoluteSize);
+    inline void addRoundedRect(qreal x, qreal y, qreal w, qreal h,
+                               qreal xRadius, qreal yRadius,
+                               Qt::SizeMode mode = Qt::AbsoluteSize);
+
+    void addRoundRect(const QRectF &rect, int xRnd, int yRnd);
+    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                             int xRnd, int yRnd);
+    inline void addRoundRect(const QRectF &rect, int roundness);
+    inline void addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                             int roundness);
+
+    void connectPath(const QPainterPath &path);
+
+    bool contains(const QPointF &pt) const;
+    bool contains(const QRectF &rect) const;
+    bool intersects(const QRectF &rect) const;
+
+    void translate(qreal dx, qreal dy);
+    inline void translate(const QPointF &offset);
+
+    QPainterPath translated(qreal dx, qreal dy) const;
+    inline QPainterPath translated(const QPointF &offset) const;
+
+    QRectF boundingRect() const;
+    QRectF controlPointRect() const;
+
+    Qt::FillRule fillRule() const;
+    void setFillRule(Qt::FillRule fillRule);
+
+    inline bool isEmpty() const;
+
+    QPainterPath toReversed() const;
+    QList<QPolygonF> toSubpathPolygons(const QMatrix &matrix = QMatrix()) const;
+    QList<QPolygonF> toFillPolygons(const QMatrix &matrix = QMatrix()) const;
+    QPolygonF toFillPolygon(const QMatrix &matrix = QMatrix()) const;
+    QList<QPolygonF> toSubpathPolygons(const QTransform &matrix) const;
+    QList<QPolygonF> toFillPolygons(const QTransform &matrix) const;
+    QPolygonF toFillPolygon(const QTransform &matrix) const;
+
+    inline int elementCount() const;
+    inline const QPainterPath::Element &elementAt(int i) const;
+    inline void setElementPositionAt(int i, qreal x, qreal y);
+
+    qreal length() const;
+    qreal percentAtLength(qreal t) const;
+    QPointF pointAtPercent(qreal t) const;
+    qreal angleAtPercent(qreal t) const;
+    qreal slopeAtPercent(qreal t) const;
+
+    bool intersects(const QPainterPath &p) const;
+    bool contains(const QPainterPath &p) const;
+    QPainterPath united(const QPainterPath &r) const;
+    QPainterPath intersected(const QPainterPath &r) const;
+    QPainterPath subtracted(const QPainterPath &r) const;
+    QPainterPath subtractedInverted(const QPainterPath &r) const;
+
+    QPainterPath simplified() const;
+
+    bool operator==(const QPainterPath &other) const;
+    bool operator!=(const QPainterPath &other) const;
+
+    QPainterPath operator&(const QPainterPath &other) const;
+    QPainterPath operator|(const QPainterPath &other) const;
+    QPainterPath operator+(const QPainterPath &other) const;
+    QPainterPath operator-(const QPainterPath &other) const;
+    QPainterPath &operator&=(const QPainterPath &other);
+    QPainterPath &operator|=(const QPainterPath &other);
+    QPainterPath &operator+=(const QPainterPath &other);
+    QPainterPath &operator-=(const QPainterPath &other);
+
+private:
+    QScopedPointer<QPainterPathPrivate, QPainterPathPrivateDeleter> d_ptr;
+
+    inline void ensureData() { if (!d_ptr) ensureData_helper(); }
+    void ensureData_helper();
+    inline void detach();
+    void detach_helper();
+    void setDirty(bool);
+    void computeBoundingRect() const;
+    void computeControlPointRect() const;
+
+    QPainterPathData *d_func() const { return reinterpret_cast<QPainterPathData *>(d_ptr.data()); }
+
+    friend class QPainterPathData;
+    friend class QPainterPathStroker;
+    friend class QPainterPathStrokerPrivate;
+    friend class QMatrix;
+    friend class QTransform;
+    friend class QVectorPath;
+    friend const QVectorPath &qtVectorPathForPath(const QPainterPath &);
+
+
+    friend QDataStream &operator<<(QDataStream &, const QPainterPath &);
+    friend QDataStream &operator>>(QDataStream &, QPainterPath &);
+
+};
+
+class QPainterPathPrivate
+{
+public:
+    friend class QPainterPath;
+    friend class QPainterPathData;
+    friend class QPainterPathStroker;
+    friend class QPainterPathStrokerPrivate;
+    friend class QMatrix;
+    friend class QTransform;
+    friend class QVectorPath;
+    friend struct QPainterPathPrivateDeleter;
+
+    friend QDataStream &operator<<(QDataStream &, const QPainterPath &);
+    friend QDataStream &operator>>(QDataStream &, QPainterPath &);
+
+private:
+    QAtomicInt ref;
+    QVector<QPainterPath::Element> elements;
+};
+
+template <> class QTypeInfo<QPainterPath::Element > { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPainterPath::Element)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPainterPath::Element"; } };
+
+
+ QDataStream &operator<<(QDataStream &, const QPainterPath &);
+ QDataStream &operator>>(QDataStream &, QPainterPath &);
+
+
+class QPainterPathStroker
+{
+    inline QPainterPathStrokerPrivate* d_func() { return reinterpret_cast<QPainterPathStrokerPrivate *>(qGetPtrHelper(d_ptr)); } inline const QPainterPathStrokerPrivate* d_func() const { return reinterpret_cast<const QPainterPathStrokerPrivate *>(qGetPtrHelper(d_ptr)); } friend class QPainterPathStrokerPrivate;
+public:
+    QPainterPathStroker();
+    ~QPainterPathStroker();
+
+    void setWidth(qreal width);
+    qreal width() const;
+
+    void setCapStyle(Qt::PenCapStyle style);
+    Qt::PenCapStyle capStyle() const;
+
+    void setJoinStyle(Qt::PenJoinStyle style);
+    Qt::PenJoinStyle joinStyle() const;
+
+    void setMiterLimit(qreal length);
+    qreal miterLimit() const;
+
+    void setCurveThreshold(qreal threshold);
+    qreal curveThreshold() const;
+
+    void setDashPattern(Qt::PenStyle);
+    void setDashPattern(const QVector<qreal> &dashPattern);
+    QVector<qreal> dashPattern() const;
+
+    void setDashOffset(qreal offset);
+    qreal dashOffset() const;
+
+    QPainterPath createStroke(const QPainterPath &path) const;
+
+private:
+    friend class QX11PaintEngine;
+
+    QScopedPointer<QPainterPathStrokerPrivate> d_ptr;
+};
+
+inline void QPainterPath::moveTo(qreal x, qreal y)
+{
+    moveTo(QPointF(x, y));
+}
+
+inline void QPainterPath::lineTo(qreal x, qreal y)
+{
+    lineTo(QPointF(x, y));
+}
+
+inline void QPainterPath::arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength)
+{
+    arcTo(QRectF(x, y, w, h), startAngle, arcLength);
+}
+
+inline void QPainterPath::arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle)
+{
+    arcMoveTo(QRectF(x, y, w, h), angle);
+}
+
+inline void QPainterPath::cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y,
+                                   qreal endPtx, qreal endPty)
+{
+    cubicTo(QPointF(ctrlPt1x, ctrlPt1y), QPointF(ctrlPt2x, ctrlPt2y),
+            QPointF(endPtx, endPty));
+}
+
+inline void QPainterPath::quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty)
+{
+    quadTo(QPointF(ctrlPtx, ctrlPty), QPointF(endPtx, endPty));
+}
+
+inline void QPainterPath::addEllipse(qreal x, qreal y, qreal w, qreal h)
+{
+    addEllipse(QRectF(x, y, w, h));
+}
+
+inline void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)
+{
+    addEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry));
+}
+
+inline void QPainterPath::addRect(qreal x, qreal y, qreal w, qreal h)
+{
+    addRect(QRectF(x, y, w, h));
+}
+
+inline void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h,
+                                         qreal xRadius, qreal yRadius,
+                                         Qt::SizeMode mode)
+{
+    addRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode);
+}
+
+inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                                       int xRnd, int yRnd)
+{
+    addRoundRect(QRectF(x, y, w, h), xRnd, yRnd);
+}
+
+inline void QPainterPath::addRoundRect(const QRectF &rect,
+                                       int roundness)
+{
+    int xRnd = roundness;
+    int yRnd = roundness;
+    if (rect.width() > rect.height())
+        xRnd = int(roundness * rect.height()/rect.width());
+    else
+        yRnd = int(roundness * rect.width()/rect.height());
+    addRoundRect(rect, xRnd, yRnd);
+}
+
+inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h,
+                                       int roundness)
+{
+    addRoundRect(QRectF(x, y, w, h), roundness);
+}
+
+inline void QPainterPath::addText(qreal x, qreal y, const QFont &f, const QString &text)
+{
+    addText(QPointF(x, y), f, text);
+}
+
+inline void QPainterPath::translate(const QPointF &offset)
+{ translate(offset.x(), offset.y()); }
+
+inline QPainterPath QPainterPath::translated(const QPointF &offset) const
+{ return translated(offset.x(), offset.y()); }
+
+inline bool QPainterPath::isEmpty() const
+{
+    return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement);
+}
+
+inline int QPainterPath::elementCount() const
+{
+    return d_ptr ? d_ptr->elements.size() : 0;
+}
+
+inline const QPainterPath::Element &QPainterPath::elementAt(int i) const
+{
+    ((!(d_ptr)) ? qt_assert("d_ptr","/usr/include/qt4/QtGui/qpainterpath.h",397) : qt_noop());
+    ((!(i >= 0 && i < elementCount())) ? qt_assert("i >= 0 && i < elementCount()","/usr/include/qt4/QtGui/qpainterpath.h",398) : qt_noop());
+    return d_ptr->elements.at(i);
+}
+
+inline void QPainterPath::setElementPositionAt(int i, qreal x, qreal y)
+{
+    ((!(d_ptr)) ? qt_assert("d_ptr","/usr/include/qt4/QtGui/qpainterpath.h",404) : qt_noop());
+    ((!(i >= 0 && i < elementCount())) ? qt_assert("i >= 0 && i < elementCount()","/usr/include/qt4/QtGui/qpainterpath.h",405) : qt_noop());
+    detach();
+    QPainterPath::Element &e = d_ptr->elements[i];
+    e.x = x;
+    e.y = y;
+}
+
+
+inline void QPainterPath::detach()
+{
+    if (d_ptr->ref != 1)
+        detach_helper();
+    setDirty(true);
+}
+
+
+ QDebug operator<<(QDebug, const QPainterPath &);
+
+
+
+
+
+# 46 "/usr/include/qt4/QtGui/qtransform.h" 2
+# 57 "/usr/include/qt4/QtGui/qtransform.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QVariant;
+
+class QTransform
+{
+   
+public:
+    enum TransformationType {
+        TxNone = 0x00,
+        TxTranslate = 0x01,
+        TxScale = 0x02,
+        TxRotate = 0x04,
+        TxShear = 0x08,
+        TxProject = 0x10
+    };
+
+    inline explicit QTransform(Qt::Initialization) : affine(Qt::Uninitialized) {}
+    QTransform();
+    QTransform(qreal h11, qreal h12, qreal h13,
+               qreal h21, qreal h22, qreal h23,
+               qreal h31, qreal h32, qreal h33 = 1.0);
+    QTransform(qreal h11, qreal h12, qreal h21,
+               qreal h22, qreal dx, qreal dy);
+    explicit QTransform(const QMatrix &mtx);
+
+    bool isAffine() const;
+    bool isIdentity() const;
+    bool isInvertible() const;
+    bool isScaling() const;
+    bool isRotating() const;
+    bool isTranslating() const;
+
+    TransformationType type() const;
+
+    inline qreal determinant() const;
+    qreal det() const;
+
+    qreal m11() const;
+    qreal m12() const;
+    qreal m13() const;
+    qreal m21() const;
+    qreal m22() const;
+    qreal m23() const;
+    qreal m31() const;
+    qreal m32() const;
+    qreal m33() const;
+    qreal dx() const;
+    qreal dy() const;
+
+    void setMatrix(qreal m11, qreal m12, qreal m13,
+                   qreal m21, qreal m22, qreal m23,
+                   qreal m31, qreal m32, qreal m33);
+
+    QTransform inverted(bool *invertible = 0) const;
+    QTransform adjoint() const;
+    QTransform transposed() const;
+
+    QTransform &translate(qreal dx, qreal dy);
+    QTransform &scale(qreal sx, qreal sy);
+    QTransform &shear(qreal sh, qreal sv);
+    QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis);
+    QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis);
+
+    static bool squareToQuad(const QPolygonF &square, QTransform &result);
+    static bool quadToSquare(const QPolygonF &quad, QTransform &result);
+    static bool quadToQuad(const QPolygonF &one,
+                           const QPolygonF &two,
+                           QTransform &result);
+
+    bool operator==(const QTransform &) const;
+    bool operator!=(const QTransform &) const;
+
+    QTransform &operator*=(const QTransform &);
+    QTransform operator*(const QTransform &o) const;
+
+    QTransform &operator=(const QTransform &);
+
+    operator QVariant() const;
+
+    void reset();
+    QPoint map(const QPoint &p) const;
+    QPointF map(const QPointF &p) const;
+    QLine map(const QLine &l) const;
+    QLineF map(const QLineF &l) const;
+    QPolygonF map(const QPolygonF &a) const;
+    QPolygon map(const QPolygon &a) const;
+    QRegion map(const QRegion &r) const;
+    QPainterPath map(const QPainterPath &p) const;
+    QPolygon mapToPolygon(const QRect &r) const;
+    QRect mapRect(const QRect &) const;
+    QRectF mapRect(const QRectF &) const;
+    void map(int x, int y, int *tx, int *ty) const;
+    void map(qreal x, qreal y, qreal *tx, qreal *ty) const;
+
+    const QMatrix &toAffine() const;
+
+    QTransform &operator*=(qreal div);
+    QTransform &operator/=(qreal div);
+    QTransform &operator+=(qreal div);
+    QTransform &operator-=(qreal div);
+
+    static QTransform fromTranslate(qreal dx, qreal dy);
+    static QTransform fromScale(qreal dx, qreal dy);
+
+private:
+    inline QTransform(qreal h11, qreal h12, qreal h13,
+                      qreal h21, qreal h22, qreal h23,
+                      qreal h31, qreal h32, qreal h33, bool)
+        : affine(h11, h12, h21, h22, h31, h32, true)
+        , m_13(h13), m_23(h23), m_33(h33)
+        , m_type(TxNone)
+        , m_dirty(TxProject) {}
+    inline QTransform(bool)
+        : affine(true)
+        , m_13(0), m_23(0), m_33(1)
+        , m_type(TxNone)
+        , m_dirty(TxNone) {}
+    inline TransformationType inline_type() const;
+    QMatrix affine;
+    qreal m_13;
+    qreal m_23;
+    qreal m_33;
+
+    mutable uint m_type : 5;
+    mutable uint m_dirty : 5;
+
+    class Private;
+    Private *d;
+};
+template <> class QTypeInfo<QTransform > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTransform)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTransform"; } };
+
+
+inline QTransform::TransformationType QTransform::inline_type() const
+{
+    if (m_dirty == TxNone)
+        return static_cast<TransformationType>(m_type);
+    return type();
+}
+
+inline bool QTransform::isAffine() const
+{
+    return inline_type() < TxProject;
+}
+inline bool QTransform::isIdentity() const
+{
+    return inline_type() == TxNone;
+}
+
+inline bool QTransform::isInvertible() const
+{
+    return !qFuzzyIsNull(determinant());
+}
+
+inline bool QTransform::isScaling() const
+{
+    return type() >= TxScale;
+}
+inline bool QTransform::isRotating() const
+{
+    return inline_type() >= TxRotate;
+}
+
+inline bool QTransform::isTranslating() const
+{
+    return inline_type() >= TxTranslate;
+}
+
+inline qreal QTransform::determinant() const
+{
+    return affine._m11*(m_33*affine._m22-affine._dy*m_23) -
+        affine._m21*(m_33*affine._m12-affine._dy*m_13)+affine._dx*(m_23*affine._m12-affine._m22*m_13);
+}
+inline qreal QTransform::det() const
+{
+    return determinant();
+}
+inline qreal QTransform::m11() const
+{
+    return affine._m11;
+}
+inline qreal QTransform::m12() const
+{
+    return affine._m12;
+}
+inline qreal QTransform::m13() const
+{
+    return m_13;
+}
+inline qreal QTransform::m21() const
+{
+    return affine._m21;
+}
+inline qreal QTransform::m22() const
+{
+    return affine._m22;
+}
+inline qreal QTransform::m23() const
+{
+    return m_23;
+}
+inline qreal QTransform::m31() const
+{
+    return affine._dx;
+}
+inline qreal QTransform::m32() const
+{
+    return affine._dy;
+}
+inline qreal QTransform::m33() const
+{
+    return m_33;
+}
+inline qreal QTransform::dx() const
+{
+    return affine._dx;
+}
+inline qreal QTransform::dy() const
+{
+    return affine._dy;
+}
+
+inline QTransform &QTransform::operator*=(qreal num)
+{
+    if (num == 1.)
+        return *this;
+    affine._m11 *= num;
+    affine._m12 *= num;
+    m_13 *= num;
+    affine._m21 *= num;
+    affine._m22 *= num;
+    m_23 *= num;
+    affine._dx *= num;
+    affine._dy *= num;
+    m_33 *= num;
+    m_dirty |= TxScale;
+    return *this;
+}
+inline QTransform &QTransform::operator/=(qreal div)
+{
+    if (div == 0)
+        return *this;
+    div = 1/div;
+    return operator*=(div);
+}
+inline QTransform &QTransform::operator+=(qreal num)
+{
+    if (num == 0)
+        return *this;
+    affine._m11 += num;
+    affine._m12 += num;
+    m_13 += num;
+    affine._m21 += num;
+    affine._m22 += num;
+    m_23 += num;
+    affine._dx += num;
+    affine._dy += num;
+    m_33 += num;
+    m_dirty |= TxProject;
+    return *this;
+}
+inline QTransform &QTransform::operator-=(qreal num)
+{
+    if (num == 0)
+        return *this;
+    affine._m11 -= num;
+    affine._m12 -= num;
+    m_13 -= num;
+    affine._m21 -= num;
+    affine._m22 -= num;
+    m_23 -= num;
+    affine._dx -= num;
+    affine._dy -= num;
+    m_33 -= num;
+    m_dirty |= TxProject;
+    return *this;
+}
+
+inline bool qFuzzyCompare(const QTransform& t1, const QTransform& t2)
+{
+    return qFuzzyCompare(t1.m11(), t2.m11())
+        && qFuzzyCompare(t1.m12(), t2.m12())
+        && qFuzzyCompare(t1.m13(), t2.m13())
+        && qFuzzyCompare(t1.m21(), t2.m21())
+        && qFuzzyCompare(t1.m22(), t2.m22())
+        && qFuzzyCompare(t1.m23(), t2.m23())
+        && qFuzzyCompare(t1.m31(), t2.m31())
+        && qFuzzyCompare(t1.m32(), t2.m32())
+        && qFuzzyCompare(t1.m33(), t2.m33());
+}
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QTransform &);
+ QDataStream &operator>>(QDataStream &, QTransform &);
+
+
+
+ QDebug operator<<(QDebug, const QTransform &);
+
+
+
+
+ inline QPoint operator*(const QPoint &p, const QTransform &m)
+{ return m.map(p); }
+ inline QPointF operator*(const QPointF &p, const QTransform &m)
+{ return m.map(p); }
+ inline QLineF operator*(const QLineF &l, const QTransform &m)
+{ return m.map(l); }
+ inline QLine operator*(const QLine &l, const QTransform &m)
+{ return m.map(l); }
+ inline QPolygon operator *(const QPolygon &a, const QTransform &m)
+{ return m.map(a); }
+ inline QPolygonF operator *(const QPolygonF &a, const QTransform &m)
+{ return m.map(a); }
+ inline QRegion operator *(const QRegion &r, const QTransform &m)
+{ return m.map(r); }
+ inline QPainterPath operator *(const QPainterPath &p, const QTransform &m)
+{ return m.map(p); }
+
+ inline QTransform operator *(const QTransform &a, qreal n)
+{ QTransform t(a); t *= n; return t; }
+ inline QTransform operator /(const QTransform &a, qreal n)
+{ QTransform t(a); t /= n; return t; }
+ inline QTransform operator +(const QTransform &a, qreal n)
+{ QTransform t(a); t += n; return t; }
+ inline QTransform operator -(const QTransform &a, qreal n)
+{ QTransform t(a); t -= n; return t; }
+
+
+
+
+# 46 "/usr/include/qt4/QtGui/qimage.h" 2
+
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QIODevice;
+class QStringList;
+class QMatrix;
+class QTransform;
+class QVariant;
+template <class T> class QList;
+template <class T> class QVector;
+
+struct QImageData;
+class QImageDataMisc;
+
+class QImageTextKeyLang {
+public:
+    QImageTextKeyLang(const char* k, const char* l) : key(k), lang(l) { }
+    QImageTextKeyLang() { }
+
+    QByteArray key;
+    QByteArray lang;
+
+    bool operator< (const QImageTextKeyLang& other) const
+        { return key < other.key || (key==other.key && lang < other.lang); }
+    bool operator== (const QImageTextKeyLang& other) const
+        { return key==other.key && lang==other.lang; }
+    inline bool operator!= (const QImageTextKeyLang &other) const
+        { return !operator==(other); }
+};
+
+
+
+class QImage : public QPaintDevice
+{
+public:
+    enum InvertMode { InvertRgb, InvertRgba };
+    enum Format {
+        Format_Invalid,
+        Format_Mono,
+        Format_MonoLSB,
+        Format_Indexed8,
+        Format_RGB32,
+        Format_ARGB32,
+        Format_ARGB32_Premultiplied,
+        Format_RGB16,
+        Format_ARGB8565_Premultiplied,
+        Format_RGB666,
+        Format_ARGB6666_Premultiplied,
+        Format_RGB555,
+        Format_ARGB8555_Premultiplied,
+        Format_RGB888,
+        Format_RGB444,
+        Format_ARGB4444_Premultiplied,
+# 119 "/usr/include/qt4/QtGui/qimage.h"
+        NImageFormats
+
+    };
+
+    QImage();
+    QImage(const QSize &size, Format format);
+    QImage(int width, int height, Format format);
+    QImage(uchar *data, int width, int height, Format format);
+    QImage(const uchar *data, int width, int height, Format format);
+    QImage(uchar *data, int width, int height, int bytesPerLine, Format format);
+    QImage(const uchar *data, int width, int height, int bytesPerLine, Format format);
+
+
+    explicit QImage(const char * const xpm[]);
+
+    explicit QImage(const QString &fileName, const char *format = 0);
+
+    explicit QImage(const char *fileName, const char *format = 0);
+
+
+    QImage(const QImage &);
+    ~QImage();
+
+    QImage &operator=(const QImage &);
+    bool isNull() const;
+
+    int devType() const;
+
+    bool operator==(const QImage &) const;
+    bool operator!=(const QImage &) const;
+    operator QVariant() const;
+    void detach();
+    bool isDetached() const;
+
+    QImage copy(const QRect &rect = QRect()) const;
+    inline QImage copy(int x, int y, int w, int h) const
+        { return copy(QRect(x, y, w, h)); }
+
+    Format format() const;
+
+    QImage convertToFormat(Format f, Qt::ImageConversionFlags flags = Qt::AutoColor) const __attribute__ ((warn_unused_result));
+    QImage convertToFormat(Format f, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const __attribute__ ((warn_unused_result));
+
+    int width() const;
+    int height() const;
+    QSize size() const;
+    QRect rect() const;
+
+    int depth() const;
+
+    int numColors() const;
+
+    int colorCount() const;
+
+    QRgb color(int i) const;
+    void setColor(int i, QRgb c);
+
+    void setNumColors(int);
+
+    void setColorCount(int);
+
+    bool allGray() const;
+    bool isGrayscale() const;
+
+    uchar *bits();
+    const uchar *bits() const;
+
+    int numBytes() const;
+
+    int byteCount() const;
+
+    uchar *scanLine(int);
+    const uchar *scanLine(int) const;
+    int bytesPerLine() const;
+
+    bool valid(int x, int y) const;
+    bool valid(const QPoint &pt) const;
+
+    int pixelIndex(int x, int y) const;
+    int pixelIndex(const QPoint &pt) const;
+
+    QRgb pixel(int x, int y) const;
+    QRgb pixel(const QPoint &pt) const;
+
+    void setPixel(int x, int y, uint index_or_rgb);
+    void setPixel(const QPoint &pt, uint index_or_rgb);
+
+    QVector<QRgb> colorTable() const;
+    void setColorTable(const QVector<QRgb> colors);
+
+    void fill(uint pixel);
+
+    bool hasAlphaChannel() const;
+    void setAlphaChannel(const QImage &alphaChannel);
+    QImage alphaChannel() const;
+    QImage createAlphaMask(Qt::ImageConversionFlags flags = Qt::AutoColor) const;
+
+    QImage createHeuristicMask(bool clipTight = true) const;
+
+    QImage createMaskFromColor(QRgb color, Qt::MaskMode mode = Qt::MaskInColor) const;
+
+    inline QImage scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                        Qt::TransformationMode mode = Qt::FastTransformation) const
+        { return scaled(QSize(w, h), aspectMode, mode); }
+    QImage scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                 Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QImage transformed(const QMatrix &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QMatrix trueMatrix(const QMatrix &, int w, int h);
+    QImage transformed(const QTransform &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QTransform trueMatrix(const QTransform &, int w, int h);
+    QImage mirrored(bool horizontally = false, bool vertically = true) const;
+    QImage rgbSwapped() const;
+    void invertPixels(InvertMode = InvertRgb);
+
+
+    bool load(QIODevice *device, const char* format);
+    bool load(const QString &fileName, const char* format=0);
+    bool loadFromData(const uchar *buf, int len, const char *format = 0);
+    inline bool loadFromData(const QByteArray &data, const char* aformat=0)
+        { return loadFromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), aformat); }
+
+    bool save(const QString &fileName, const char* format=0, int quality=-1) const;
+    bool save(QIODevice *device, const char* format=0, int quality=-1) const;
+
+    static QImage fromData(const uchar *data, int size, const char *format = 0);
+    inline static QImage fromData(const QByteArray &data, const char *format = 0)
+        { return fromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), format); }
+
+    int serialNumber() const;
+    qint64 cacheKey() const;
+
+    QPaintEngine *paintEngine() const;
+
+
+    int dotsPerMeterX() const;
+    int dotsPerMeterY() const;
+    void setDotsPerMeterX(int);
+    void setDotsPerMeterY(int);
+    QPoint offset() const;
+    void setOffset(const QPoint&);
+
+    QStringList textKeys() const;
+    QString text(const QString &key = QString()) const;
+    void setText(const QString &key, const QString &value);
+
+
+    QString text(const char* key, const char* lang=0) const;
+    QList<QImageTextKeyLang> textList() const;
+    QStringList textLanguages() const;
+    QString text(const QImageTextKeyLang&) const;
+    void setText(const char* key, const char* lang, const QString&);
+# 318 "/usr/include/qt4/QtGui/qimage.h"
+public:
+    virtual int metric(PaintDeviceMetric metric) const;
+
+private:
+    friend class QWSOnScreenSurface;
+    QImageData *d;
+
+    friend class QRasterPixmapData;
+    friend class QPixmapCacheEntry;
+    friend qint64 qt_image_id(const QImage &image);
+    friend const QVector<QRgb> *qt_image_colortable(const QImage &image);
+
+public:
+    typedef QImageData * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+template <> inline bool qIsDetached<QImage>(QImage &t) { return t.isDetached(); } template <> inline void qSwap<QImage>(QImage &value1, QImage &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+template <> class QTypeInfo<QImage > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QImage)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QImage"; } };
+
+
+
+ inline bool QImage::valid(const QPoint &pt) const { return valid(pt.x(), pt.y()); }
+ inline int QImage::pixelIndex(const QPoint &pt) const { return pixelIndex(pt.x(), pt.y());}
+ inline QRgb QImage::pixel(const QPoint &pt) const { return pixel(pt.x(), pt.y()); }
+ inline void QImage::setPixel(const QPoint &pt, uint index_or_rgb) { setPixel(pt.x(), pt.y(), index_or_rgb); }
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QImage &);
+ QDataStream &operator>>(QDataStream &, QImage &);
+
+
+
+
+
+
+
+
+
+
+# 51 "/usr/include/qt4/QtGui/qpixmap.h" 2
+
+
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QImageWriter;
+class QColor;
+class QVariant;
+class QX11Info;
+class QPixmapData;
+
+class QPixmap : public QPaintDevice
+{
+public:
+    QPixmap();
+    explicit QPixmap(QPixmapData *data);
+    QPixmap(int w, int h);
+    QPixmap(const QSize &);
+    QPixmap(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+
+    QPixmap(const char * const xpm[]);
+
+    QPixmap(const QPixmap &);
+    ~QPixmap();
+
+    QPixmap &operator=(const QPixmap &);
+    operator QVariant() const;
+
+    bool isNull() const;
+    int devType() const;
+
+    int width() const;
+    int height() const;
+    QSize size() const;
+    QRect rect() const;
+    int depth() const;
+
+    static int defaultDepth();
+
+    void fill(const QColor &fillColor = Qt::white);
+    void fill(const QWidget *widget, const QPoint &ofs);
+    inline void fill(const QWidget *widget, int xofs, int yofs) { fill(widget, QPoint(xofs, yofs)); }
+
+    QBitmap mask() const;
+    void setMask(const QBitmap &);
+
+    QPixmap alphaChannel() const;
+    void setAlphaChannel(const QPixmap &);
+
+    bool hasAlpha() const;
+    bool hasAlphaChannel() const;
+
+
+    QBitmap createHeuristicMask(bool clipTight = true) const;
+
+    QBitmap createMaskFromColor(const QColor &maskColor) const;
+    QBitmap createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode) const;
+
+    static QPixmap grabWindow(WId, int x=0, int y=0, int w=-1, int h=-1);
+    static QPixmap grabWidget(QWidget *widget, const QRect &rect);
+    static inline QPixmap grabWidget(QWidget *widget, int x=0, int y=0, int w=-1, int h=-1)
+    { return grabWidget(widget, QRect(x, y, w, h)); }
+
+
+    inline QPixmap scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                          Qt::TransformationMode mode = Qt::FastTransformation) const
+        { return scaled(QSize(w, h), aspectMode, mode); }
+    QPixmap scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio,
+                   Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    QPixmap transformed(const QMatrix &, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QMatrix trueMatrix(const QMatrix &m, int w, int h);
+    QPixmap transformed(const QTransform &, Qt::TransformationMode mode = Qt::FastTransformation) const;
+    static QTransform trueMatrix(const QTransform &m, int w, int h);
+
+    QImage toImage() const;
+    static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor);
+
+    bool load(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    bool loadFromData(const uchar *buf, uint len, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    inline bool loadFromData(const QByteArray &data, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor);
+    bool save(const QString& fileName, const char* format = 0, int quality = -1) const;
+    bool save(QIODevice* device, const char* format = 0, int quality = -1) const;
+# 170 "/usr/include/qt4/QtGui/qpixmap.h"
+    inline QPixmap copy(int x, int y, int width, int height) const;
+    QPixmap copy(const QRect &rect = QRect()) const;
+
+    inline void scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = 0);
+    void scroll(int dx, int dy, const QRect &rect, QRegion *exposed = 0);
+
+    int serialNumber() const;
+    qint64 cacheKey() const;
+
+    bool isDetached() const;
+    void detach();
+
+    bool isQBitmap() const;
+# 197 "/usr/include/qt4/QtGui/qpixmap.h"
+    enum ShareMode { ImplicitlyShared, ExplicitlyShared };
+
+    static QPixmap fromX11Pixmap(Qt::HANDLE pixmap, ShareMode mode = ImplicitlyShared);
+    static int x11SetDefaultScreen(int screen);
+    void x11SetScreen(int screen);
+    const QX11Info &x11Info() const;
+    Qt::HANDLE x11PictureHandle() const;
+
+
+
+    Qt::HANDLE handle() const;
+
+
+    QPaintEngine *paintEngine() const;
+
+    inline bool operator!() const { return isNull(); }
+
+public:
+    int metric(PaintDeviceMetric) const;
+# 239 "/usr/include/qt4/QtGui/qpixmap.h"
+private:
+    QExplicitlySharedDataPointer<QPixmapData> data;
+
+    bool doImageIO(QImageWriter *io, int quality) const;
+
+
+    enum Type { PixmapType, BitmapType };
+    QPixmap(const QSize &s, Type);
+    void init(int, int, Type = PixmapType);
+
+    QPixmap(const QSize &s, int type);
+    void init(int, int, int);
+    void deref();
+
+
+
+   
+
+
+
+
+
+
+
+    friend class QPixmapData;
+    friend class QX11PixmapData;
+    friend class QMacPixmapData;
+    friend class QS60PixmapData;
+    friend class QBitmap;
+    friend class QPaintDevice;
+    friend class QPainter;
+    friend class QGLWidget;
+    friend class QX11PaintEngine;
+    friend class QCoreGraphicsPaintEngine;
+    friend class QWidgetPrivate;
+    friend class QRasterPaintEngine;
+    friend class QRasterBuffer;
+    friend class QPixmapCacheEntry;
+
+    friend QDataStream &operator>>(QDataStream &, QPixmap &);
+
+    friend qint64 qt_pixmap_id(const QPixmap &pixmap);
+
+public:
+    QPixmapData* pixmapData() const;
+
+public:
+    typedef QExplicitlySharedDataPointer<QPixmapData> DataPtr;
+    inline DataPtr &data_ptr() { return data; }
+};
+
+template <> inline bool qIsDetached<QPixmap>(QPixmap &t) { return t.isDetached(); } template <> inline void qSwap<QPixmap>(QPixmap &value1, QPixmap &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+
+inline QPixmap QPixmap::copy(int ax, int ay, int awidth, int aheight) const
+{
+    return copy(QRect(ax, ay, awidth, aheight));
+}
+
+inline void QPixmap::scroll(int dx, int dy, int ax, int ay, int awidth, int aheight, QRegion *exposed)
+{
+    scroll(dx, dy, QRect(ax, ay, awidth, aheight), exposed);
+}
+
+inline bool QPixmap::loadFromData(const QByteArray &buf, const char *format,
+                                  Qt::ImageConversionFlags flags)
+{
+    return loadFromData(reinterpret_cast<const uchar *>(buf.constData()), buf.size(), format, flags);
+}
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QPixmap &);
+ QDataStream &operator>>(QDataStream &, QPixmap &);
+# 325 "/usr/include/qt4/QtGui/qpixmap.h"
+
+
+
+# 27 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2
+# 1 "/usr/include/qt4/QtGui/qicon.h" 1
+# 50 "/usr/include/qt4/QtGui/qicon.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QIconPrivate;
+class QIconEngine;
+class QIconEngineV2;
+
+class QIcon
+{
+public:
+    enum Mode { Normal, Disabled, Active, Selected };
+    enum State { On, Off };
+
+    QIcon();
+    QIcon(const QPixmap &pixmap);
+    QIcon(const QIcon &other);
+    explicit QIcon(const QString &fileName);
+    explicit QIcon(QIconEngine *engine);
+    explicit QIcon(QIconEngineV2 *engine);
+    ~QIcon();
+    QIcon &operator=(const QIcon &other);
+    operator QVariant() const;
+
+    QPixmap pixmap(const QSize &size, Mode mode = Normal, State state = Off) const;
+    inline QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const
+        { return pixmap(QSize(w, h), mode, state); }
+    inline QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const
+        { return pixmap(QSize(extent, extent), mode, state); }
+
+    QSize actualSize(const QSize &size, Mode mode = Normal, State state = Off) const;
+
+    void paint(QPainter *painter, const QRect &rect, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const;
+    inline void paint(QPainter *painter, int x, int y, int w, int h, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const
+        { paint(painter, QRect(x, y, w, h), alignment, mode, state); }
+
+    bool isNull() const;
+    bool isDetached() const;
+    void detach();
+
+    int serialNumber() const;
+    qint64 cacheKey() const;
+
+    void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off);
+    void addFile(const QString &fileName, const QSize &size = QSize(), Mode mode = Normal, State state = Off);
+
+    QList<QSize> availableSizes(Mode mode = Normal, State state = Off) const;
+
+    static QIcon fromTheme(const QString &name, const QIcon &fallback = QIcon());
+    static bool hasThemeIcon(const QString &name);
+
+    static QStringList themeSearchPaths();
+    static void setThemeSearchPaths(const QStringList &searchpath);
+
+    static QString themeName();
+    static void setThemeName(const QString &path);
+# 124 "/usr/include/qt4/QtGui/qicon.h"
+   
+
+private:
+    QIconPrivate *d;
+
+    friend QDataStream &operator<<(QDataStream &, const QIcon &);
+    friend QDataStream &operator>>(QDataStream &, QIcon &);
+
+
+public:
+    typedef QIconPrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+template <> inline bool qIsDetached<QIcon>(QIcon &t) { return t.isDetached(); } template <> inline void qSwap<QIcon>(QIcon &value1, QIcon &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+template <> class QTypeInfo<QIcon > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QIcon)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QIcon"; } };
+
+
+ QDataStream &operator<<(QDataStream &, const QIcon &);
+ QDataStream &operator>>(QDataStream &, QIcon &);
+
+
+
+
+
+
+
+
+
+# 28 "/usr/include/qt4/QtWebKit/qwebsettings.h" 2
+
+
+namespace WebCore {
+    class Settings;
+}
+
+class QWebPage;
+class QWebPluginDatabase;
+class QWebSettingsPrivate;
+
+class QUrl;
+
+
+class QWebSettings {
+public:
+    enum FontFamily {
+        StandardFont,
+        FixedFont,
+        SerifFont,
+        SansSerifFont,
+        CursiveFont,
+        FantasyFont
+    };
+    enum WebAttribute {
+        AutoLoadImages,
+        JavascriptEnabled,
+        JavaEnabled,
+        PluginsEnabled,
+        PrivateBrowsingEnabled,
+        JavascriptCanOpenWindows,
+        JavascriptCanAccessClipboard,
+        DeveloperExtrasEnabled,
+        LinksIncludedInFocusChain,
+        ZoomTextOnly,
+        PrintElementBackgrounds,
+        OfflineStorageDatabaseEnabled,
+        OfflineWebApplicationCacheEnabled,
+        LocalStorageEnabled,
+
+        LocalStorageDatabaseEnabled = LocalStorageEnabled,
+
+        LocalContentCanAccessRemoteUrls,
+        DnsPrefetchEnabled
+    };
+    enum WebGraphic {
+        MissingImageGraphic,
+        MissingPluginGraphic,
+        DefaultFrameIconGraphic,
+        TextAreaSizeGripCornerGraphic
+    };
+    enum FontSize {
+        MinimumFontSize,
+        MinimumLogicalFontSize,
+        DefaultFontSize,
+        DefaultFixedFontSize
+    };
+
+    static QWebSettings *globalSettings();
+
+    void setFontFamily(FontFamily which, const QString &family);
+    QString fontFamily(FontFamily which) const;
+    void resetFontFamily(FontFamily which);
+
+    void setFontSize(FontSize type, int size);
+    int fontSize(FontSize type) const;
+    void resetFontSize(FontSize type);
+
+    void setAttribute(WebAttribute attr, bool on);
+    bool testAttribute(WebAttribute attr) const;
+    void resetAttribute(WebAttribute attr);
+
+    void setUserStyleSheetUrl(const QUrl &location);
+    QUrl userStyleSheetUrl() const;
+
+    void setDefaultTextEncoding(const QString &encoding);
+    QString defaultTextEncoding() const;
+
+    static void setIconDatabasePath(const QString &location);
+    static QString iconDatabasePath();
+    static void clearIconDatabase();
+    static QIcon iconForUrl(const QUrl &url);
+
+
+
+    static void setWebGraphic(WebGraphic type, const QPixmap &graphic);
+    static QPixmap webGraphic(WebGraphic type);
+
+    static void setMaximumPagesInCache(int pages);
+    static int maximumPagesInCache();
+    static void setObjectCacheCapacities(int cacheMinDeadCapacity, int cacheMaxDead, int totalCapacity);
+
+    static void setOfflineStoragePath(const QString& path);
+    static QString offlineStoragePath();
+    static void setOfflineStorageDefaultQuota(qint64 maximumSize);
+    static qint64 offlineStorageDefaultQuota();
+
+    static void setOfflineWebApplicationCachePath(const QString& path);
+    static QString offlineWebApplicationCachePath();
+    static void setOfflineWebApplicationCacheQuota(qint64 maximumSize);
+    static qint64 offlineWebApplicationCacheQuota();
+
+    void setLocalStoragePath(const QString& path);
+    QString localStoragePath() const;
+
+    static void clearMemoryCaches();
+
+    static void enablePersistentStorage(const QString& path = QString());
+
+    inline QWebSettingsPrivate* handle() const { return d; }
+
+private:
+    friend class QWebPagePrivate;
+    friend class QWebSettingsPrivate;
+
+    QWebSettings(const QWebSettings &); QWebSettings &operator=(const QWebSettings &);
+
+    QWebSettings();
+    QWebSettings(WebCore::Settings *settings);
+    ~QWebSettings();
+
+    QWebSettingsPrivate *d;
+};
+# 25 "/usr/include/qt4/QtWebKit/qwebpage.h" 2
+
+
+
+# 1 "/usr/include/qt4/QtCore/qurl.h" 1
+# 47 "/usr/include/qt4/QtCore/qurl.h"
+# 1 "/usr/include/qt4/QtCore/qpair.h" 1
+# 47 "/usr/include/qt4/QtCore/qpair.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+template <class T1, class T2>
+struct QPair
+{
+    typedef T1 first_type;
+    typedef T2 second_type;
+
+    QPair() : first(T1()), second(T2()) {}
+    QPair(const T1 &t1, const T2 &t2) : first(t1), second(t2) {}
+
+    QPair<T1, T2> &operator=(const QPair<T1, T2> &other)
+    { first = other.first; second = other.second; return *this; }
+
+    T1 first;
+    T2 second;
+};
+
+template <class T1, class T2>
+inline bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{ return p1.first == p2.first && p1.second == p2.second; }
+
+template <class T1, class T2>
+inline bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{ return !(p1 == p2); }
+
+template <class T1, class T2>
+inline bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second);
+}
+
+template <class T1, class T2>
+inline bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return p2 < p1;
+}
+
+template <class T1, class T2>
+inline bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return !(p2 < p1);
+}
+
+template <class T1, class T2>
+inline bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
+{
+    return !(p1 < p2);
+}
+
+template <class T1, class T2>
+ QPair<T1, T2> qMakePair(const T1 &x, const T2 &y)
+{
+    return QPair<T1, T2>(x, y);
+}
+
+
+template <class T1, class T2>
+inline QDataStream& operator>>(QDataStream& s, QPair<T1, T2>& p)
+{
+    s >> p.first >> p.second;
+    return s;
+}
+
+template <class T1, class T2>
+inline QDataStream& operator<<(QDataStream& s, const QPair<T1, T2>& p)
+{
+    s << p.first << p.second;
+    return s;
+}
+
+
+
+
+
+# 48 "/usr/include/qt4/QtCore/qurl.h" 2
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QUrlPrivate;
+class QDataStream;
+
+class QUrl
+{
+public:
+    enum ParsingMode {
+        TolerantMode,
+        StrictMode
+    };
+
+
+    enum FormattingOption {
+        None = 0x0,
+        RemoveScheme = 0x1,
+        RemovePassword = 0x2,
+        RemoveUserInfo = RemovePassword | 0x4,
+        RemovePort = 0x8,
+        RemoveAuthority = RemoveUserInfo | RemovePort | 0x10,
+        RemovePath = 0x20,
+        RemoveQuery = 0x40,
+        RemoveFragment = 0x80,
+
+        StripTrailingSlash = 0x10000
+    };
+    typedef QFlags<FormattingOption> FormattingOptions;
+
+    QUrl();
+
+
+
+    QUrl(const QString &url);
+    QUrl(const QString &url, ParsingMode mode);
+
+    QUrl(const QUrl &copy);
+    QUrl &operator =(const QUrl &copy);
+
+    QUrl &operator =(const QString &url);
+
+    ~QUrl();
+
+    void setUrl(const QString &url);
+    void setUrl(const QString &url, ParsingMode mode);
+
+    void setEncodedUrl(const QByteArray &url);
+    void setEncodedUrl(const QByteArray &url, ParsingMode mode);
+
+
+    bool isValid() const;
+
+    bool isEmpty() const;
+
+    void clear();
+
+    void setScheme(const QString &scheme);
+    QString scheme() const;
+
+    void setAuthority(const QString &authority);
+    QString authority() const;
+
+    void setUserInfo(const QString &userInfo);
+    QString userInfo() const;
+
+    void setUserName(const QString &userName);
+    QString userName() const;
+    void setEncodedUserName(const QByteArray &userName);
+    QByteArray encodedUserName() const;
+
+    void setPassword(const QString &password);
+    QString password() const;
+    void setEncodedPassword(const QByteArray &password);
+    QByteArray encodedPassword() const;
+
+    void setHost(const QString &host);
+    QString host() const;
+    void setEncodedHost(const QByteArray &host);
+    QByteArray encodedHost() const;
+
+    void setPort(int port);
+    int port() const;
+    int port(int defaultPort) const;
+
+
+    void setPath(const QString &path);
+    QString path() const;
+    void setEncodedPath(const QByteArray &path);
+    QByteArray encodedPath() const;
+
+    bool hasQuery() const;
+
+    void setEncodedQuery(const QByteArray &query);
+    QByteArray encodedQuery() const;
+
+    void setQueryDelimiters(char valueDelimiter, char pairDelimiter);
+    char queryValueDelimiter() const;
+    char queryPairDelimiter() const;
+
+    void setQueryItems(const QList<QPair<QString, QString> > &query);
+    void addQueryItem(const QString &key, const QString &value);
+    QList<QPair<QString, QString> > queryItems() const;
+    bool hasQueryItem(const QString &key) const;
+    QString queryItemValue(const QString &key) const;
+    QStringList allQueryItemValues(const QString &key) const;
+    void removeQueryItem(const QString &key);
+    void removeAllQueryItems(const QString &key);
+
+    void setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query);
+    void addEncodedQueryItem(const QByteArray &key, const QByteArray &value);
+    QList<QPair<QByteArray, QByteArray> > encodedQueryItems() const;
+    bool hasEncodedQueryItem(const QByteArray &key) const;
+    QByteArray encodedQueryItemValue(const QByteArray &key) const;
+    QList<QByteArray> allEncodedQueryItemValues(const QByteArray &key) const;
+    void removeEncodedQueryItem(const QByteArray &key);
+    void removeAllEncodedQueryItems(const QByteArray &key);
+
+    void setFragment(const QString &fragment);
+    QString fragment() const;
+    void setEncodedFragment(const QByteArray &fragment);
+    QByteArray encodedFragment() const;
+    bool hasFragment() const;
+
+    QUrl resolved(const QUrl &relative) const;
+
+    bool isRelative() const;
+    bool isParentOf(const QUrl &url) const;
+
+    static QUrl fromLocalFile(const QString &localfile);
+    QString toLocalFile() const;
+
+    QString toString(FormattingOptions options = None) const;
+
+    QByteArray toEncoded(FormattingOptions options = None) const;
+    static QUrl fromEncoded(const QByteArray &url);
+    static QUrl fromEncoded(const QByteArray &url, ParsingMode mode);
+
+
+    static QUrl fromUserInput(const QString &userInput);
+
+    void detach();
+    bool isDetached() const;
+
+    bool operator <(const QUrl &url) const;
+    bool operator ==(const QUrl &url) const;
+    bool operator !=(const QUrl &url) const;
+
+    static QString fromPercentEncoding(const QByteArray &);
+    static QByteArray toPercentEncoding(const QString &,
+                                        const QByteArray &exclude = QByteArray(),
+                                        const QByteArray &include = QByteArray());
+    static QString fromPunycode(const QByteArray &);
+    static QByteArray toPunycode(const QString &);
+    static QString fromAce(const QByteArray &);
+    static QByteArray toAce(const QString &);
+    static QStringList idnWhitelist();
+    static void setIdnWhitelist(const QStringList &);
+# 257 "/usr/include/qt4/QtCore/qurl.h"
+    QString errorString() const;
+
+public:
+
+
+
+
+private:
+    QUrlPrivate *d;
+public:
+    typedef QUrlPrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+template <> class QTypeInfo<QUrl > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QUrl)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QUrl"; } };
+template <> inline bool qIsDetached<QUrl>(QUrl &t) { return t.isDetached(); } template <> inline void qSwap<QUrl>(QUrl &value1, QUrl &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QUrl::FormattingOptions::enum_type f2) { return QFlags<QUrl::FormattingOptions::enum_type>(f1) | f2; } inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QFlags<QUrl::FormattingOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QUrl::FormattingOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+
+
+ QDataStream &operator<<(QDataStream &, const QUrl &);
+ QDataStream &operator>>(QDataStream &, QUrl &);
+
+
+
+ QDebug operator<<(QDebug, const QUrl &);
+
+
+
+
+
+# 29 "/usr/include/qt4/QtWebKit/qwebpage.h" 2
+# 1 "/usr/include/qt4/QtGui/qwidget.h" 1
+# 47 "/usr/include/qt4/QtGui/qwidget.h"
+# 1 "/usr/include/qt4/QtCore/qmargins.h" 1
+# 47 "/usr/include/qt4/QtCore/qmargins.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QMargins
+{
+public:
+    QMargins();
+    QMargins(int left, int top, int right, int bottom);
+
+    bool isNull() const;
+
+    int left() const;
+    int top() const;
+    int right() const;
+    int bottom() const;
+
+    void setLeft(int left);
+    void setTop(int top);
+    void setRight(int right);
+    void setBottom(int bottom);
+
+private:
+    int m_left;
+    int m_top;
+    int m_right;
+    int m_bottom;
+
+    friend inline bool operator==(const QMargins &, const QMargins &);
+    friend inline bool operator!=(const QMargins &, const QMargins &);
+};
+
+template <> class QTypeInfo<QMargins > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMargins)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMargins"; } };
+
+
+
+
+
+inline QMargins::QMargins()
+{ m_top = m_bottom = m_left = m_right = 0; }
+
+inline QMargins::QMargins(int aleft, int atop, int aright, int abottom)
+    : m_left(aleft), m_top(atop), m_right(aright), m_bottom(abottom) {}
+
+inline bool QMargins::isNull() const
+{ return m_left==0 && m_top==0 && m_right==0 && m_bottom==0; }
+
+inline int QMargins::left() const
+{ return m_left; }
+
+inline int QMargins::top() const
+{ return m_top; }
+
+inline int QMargins::right() const
+{ return m_right; }
+
+inline int QMargins::bottom() const
+{ return m_bottom; }
+
+
+inline void QMargins::setLeft(int aleft)
+{ m_left = aleft; }
+
+inline void QMargins::setTop(int atop)
+{ m_top = atop; }
+
+inline void QMargins::setRight(int aright)
+{ m_right = aright; }
+
+inline void QMargins::setBottom(int abottom)
+{ m_bottom = abottom; }
+
+inline bool operator==(const QMargins &m1, const QMargins &m2)
+{
+    return
+            m1.m_left == m2.m_left &&
+            m1.m_top == m2.m_top &&
+            m1.m_right == m2.m_right &&
+            m1.m_bottom == m2.m_bottom;
+}
+
+inline bool operator!=(const QMargins &m1, const QMargins &m2)
+{
+    return
+            m1.m_left != m2.m_left ||
+            m1.m_top != m2.m_top ||
+            m1.m_right != m2.m_right ||
+            m1.m_bottom != m2.m_bottom;
+}
+
+
+ QDebug operator<<(QDebug, const QMargins &);
+
+
+
+
+
+# 48 "/usr/include/qt4/QtGui/qwidget.h" 2
+
+# 1 "/usr/include/qt4/QtGui/qpalette.h" 1
+# 47 "/usr/include/qt4/QtGui/qpalette.h"
+# 1 "/usr/include/qt4/QtGui/qbrush.h" 1
+# 64 "/usr/include/qt4/QtGui/qbrush.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+struct QBrushData;
+class QPixmap;
+class QGradient;
+class QVariant;
+struct QBrushDataPointerDeleter;
+
+class QBrush
+{
+public:
+    QBrush();
+    QBrush(Qt::BrushStyle bs);
+    QBrush(const QColor &color, Qt::BrushStyle bs=Qt::SolidPattern);
+    QBrush(Qt::GlobalColor color, Qt::BrushStyle bs=Qt::SolidPattern);
+
+    QBrush(const QColor &color, const QPixmap &pixmap);
+    QBrush(Qt::GlobalColor color, const QPixmap &pixmap);
+    QBrush(const QPixmap &pixmap);
+    QBrush(const QImage &image);
+
+    QBrush(const QBrush &brush);
+
+    QBrush(const QGradient &gradient);
+
+    ~QBrush();
+    QBrush &operator=(const QBrush &brush);
+    operator QVariant() const;
+
+    inline Qt::BrushStyle style() const;
+    void setStyle(Qt::BrushStyle);
+
+    inline const QMatrix &matrix() const;
+    void setMatrix(const QMatrix &mat);
+
+    inline QTransform transform() const;
+    void setTransform(const QTransform &);
+
+    QPixmap texture() const;
+    void setTexture(const QPixmap &pixmap);
+
+    QImage textureImage() const;
+    void setTextureImage(const QImage &image);
+
+    inline const QColor &color() const;
+    void setColor(const QColor &color);
+    inline void setColor(Qt::GlobalColor color);
+
+    const QGradient *gradient() const;
+
+    bool isOpaque() const;
+
+    bool operator==(const QBrush &b) const;
+    inline bool operator!=(const QBrush &b) const { return !(operator==(b)); }
+
+
+
+
+
+
+
+private:
+
+    friend class QX11PaintEngine;
+
+    friend class QRasterPaintEngine;
+    friend class QRasterPaintEnginePrivate;
+    friend struct QSpanData;
+    friend class QPainter;
+    friend bool qHasPixmapTexture(const QBrush& brush);
+    void detach(Qt::BrushStyle newStyle);
+    void init(const QColor &color, Qt::BrushStyle bs);
+    QScopedPointer<QBrushData, QBrushDataPointerDeleter> d;
+    void cleanUp(QBrushData *x);
+
+public:
+    inline bool isDetached() const;
+    typedef QScopedPointer<QBrushData, QBrushDataPointerDeleter> DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+
+inline void QBrush::setColor(Qt::GlobalColor acolor)
+{ setColor(QColor(acolor)); }
+
+template <> class QTypeInfo<QBrush > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QBrush)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QBrush"; } };
+template <> inline bool qIsDetached<QBrush>(QBrush &t) { return t.isDetached(); } template <> inline void qSwap<QBrush>(QBrush &value1, QBrush &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QBrush &);
+ QDataStream &operator>>(QDataStream &, QBrush &);
+
+
+
+ QDebug operator<<(QDebug, const QBrush &);
+
+
+struct QBrushData
+{
+    QAtomicInt ref;
+    Qt::BrushStyle style;
+    QColor color;
+    QTransform transform;
+};
+
+inline Qt::BrushStyle QBrush::style() const { return d->style; }
+inline const QColor &QBrush::color() const { return d->color; }
+inline const QMatrix &QBrush::matrix() const { return d->transform.toAffine(); }
+inline QTransform QBrush::transform() const { return d->transform; }
+inline bool QBrush::isDetached() const { return d->ref == 1; }
+# 190 "/usr/include/qt4/QtGui/qbrush.h"
+class QGradientPrivate;
+
+typedef QPair<qreal, QColor> QGradientStop;
+typedef QVector<QGradientStop> QGradientStops;
+
+class QGradient
+{
+    public: static const QMetaObject staticMetaObject; private:
+   
+public:
+    enum Type {
+        LinearGradient,
+        RadialGradient,
+        ConicalGradient,
+        NoGradient
+    };
+
+    enum Spread {
+        PadSpread,
+        ReflectSpread,
+        RepeatSpread
+    };
+
+    enum CoordinateMode {
+        LogicalMode,
+        StretchToDeviceMode,
+        ObjectBoundingMode
+    };
+
+    enum InterpolationMode {
+        ColorInterpolation,
+        ComponentInterpolation
+    };
+
+    QGradient();
+
+    Type type() const { return m_type; }
+
+    inline void setSpread(Spread spread);
+    Spread spread() const { return m_spread; }
+
+    void setColorAt(qreal pos, const QColor &color);
+
+    void setStops(const QGradientStops &stops);
+    QGradientStops stops() const;
+
+    CoordinateMode coordinateMode() const;
+    void setCoordinateMode(CoordinateMode mode);
+
+    InterpolationMode interpolationMode() const;
+    void setInterpolationMode(InterpolationMode mode);
+
+    bool operator==(const QGradient &gradient) const;
+    inline bool operator!=(const QGradient &other) const
+    { return !operator==(other); }
+
+    bool operator==(const QGradient &gradient);
+
+private:
+    friend class QLinearGradient;
+    friend class QRadialGradient;
+    friend class QConicalGradient;
+
+    Type m_type;
+    Spread m_spread;
+    QGradientStops m_stops;
+    union {
+        struct {
+            qreal x1, y1, x2, y2;
+        } linear;
+        struct {
+            qreal cx, cy, fx, fy, radius;
+        } radial;
+        struct {
+            qreal cx, cy, angle;
+        } conical;
+    } m_data;
+    void *dummy;
+};
+
+inline void QGradient::setSpread(Spread aspread)
+{ m_spread = aspread; }
+
+class QLinearGradient : public QGradient
+{
+public:
+    QLinearGradient();
+    QLinearGradient(const QPointF &start, const QPointF &finalStop);
+    QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop);
+
+    QPointF start() const;
+    void setStart(const QPointF &start);
+    inline void setStart(qreal x, qreal y) { setStart(QPointF(x, y)); }
+
+    QPointF finalStop() const;
+    void setFinalStop(const QPointF &stop);
+    inline void setFinalStop(qreal x, qreal y) { setFinalStop(QPointF(x, y)); }
+};
+
+
+class QRadialGradient : public QGradient
+{
+public:
+    QRadialGradient();
+    QRadialGradient(const QPointF &center, qreal radius, const QPointF &focalPoint);
+    QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy);
+
+    QRadialGradient(const QPointF &center, qreal radius);
+    QRadialGradient(qreal cx, qreal cy, qreal radius);
+
+    QPointF center() const;
+    void setCenter(const QPointF &center);
+    inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }
+
+    QPointF focalPoint() const;
+    void setFocalPoint(const QPointF &focalPoint);
+    inline void setFocalPoint(qreal x, qreal y) { setFocalPoint(QPointF(x, y)); }
+
+    qreal radius() const;
+    void setRadius(qreal radius);
+};
+
+
+class QConicalGradient : public QGradient
+{
+public:
+    QConicalGradient();
+    QConicalGradient(const QPointF &center, qreal startAngle);
+    QConicalGradient(qreal cx, qreal cy, qreal startAngle);
+
+    QPointF center() const;
+    void setCenter(const QPointF &center);
+    inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); }
+
+    qreal angle() const;
+    void setAngle(qreal angle);
+};
+
+
+
+
+# 48 "/usr/include/qt4/QtGui/qpalette.h" 2
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+
+
+
+class QPalettePrivate;
+class QVariant;
+
+class QPalette
+{
+    public: static const QMetaObject staticMetaObject; private:
+   
+public:
+    QPalette();
+    QPalette(const QColor &button);
+    QPalette(Qt::GlobalColor button);
+    QPalette(const QColor &button, const QColor &window);
+    QPalette(const QBrush &windowText, const QBrush &button, const QBrush &light,
+             const QBrush &dark, const QBrush &mid, const QBrush &text,
+             const QBrush &bright_text, const QBrush &base, const QBrush &window);
+    QPalette(const QColor &windowText, const QColor &window, const QColor &light,
+             const QColor &dark, const QColor &mid, const QColor &text, const QColor &base);
+
+
+
+    QPalette(const QPalette &palette);
+    ~QPalette();
+    QPalette &operator=(const QPalette &palette);
+    operator QVariant() const;
+
+
+    enum ColorGroup { Active, Disabled, Inactive, NColorGroups, Current, All, Normal = Active };
+    enum ColorRole { WindowText, Button, Light, Midlight, Dark, Mid,
+                     Text, BrightText, ButtonText, Base, Window, Shadow,
+                     Highlight, HighlightedText,
+                     Link, LinkVisited,
+                     AlternateBase,
+                     NoRole,
+                     ToolTipBase, ToolTipText,
+                     NColorRoles = ToolTipText + 1,
+                     Foreground = WindowText, Background = Window
+                   };
+
+    inline ColorGroup currentColorGroup() const { return static_cast<ColorGroup>(current_group); }
+    inline void setCurrentColorGroup(ColorGroup cg) { current_group = cg; }
+
+    inline const QColor &color(ColorGroup cg, ColorRole cr) const
+    { return brush(cg, cr).color(); }
+    const QBrush &brush(ColorGroup cg, ColorRole cr) const;
+    inline void setColor(ColorGroup cg, ColorRole cr, const QColor &color);
+    inline void setColor(ColorRole cr, const QColor &color);
+    inline void setBrush(ColorRole cr, const QBrush &brush);
+    bool isBrushSet(ColorGroup cg, ColorRole cr) const;
+    void setBrush(ColorGroup cg, ColorRole cr, const QBrush &brush);
+    void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button,
+                       const QBrush &light, const QBrush &dark, const QBrush &mid,
+                       const QBrush &text, const QBrush &bright_text, const QBrush &base,
+                       const QBrush &window);
+    bool isEqual(ColorGroup cr1, ColorGroup cr2) const;
+
+    inline const QColor &color(ColorRole cr) const { return color(Current, cr); }
+    inline const QBrush &brush(ColorRole cr) const { return brush(Current, cr); }
+    inline const QBrush &foreground() const { return brush(WindowText); }
+    inline const QBrush &windowText() const { return brush(WindowText); }
+    inline const QBrush &button() const { return brush(Button); }
+    inline const QBrush &light() const { return brush(Light); }
+    inline const QBrush &dark() const { return brush(Dark); }
+    inline const QBrush &mid() const { return brush(Mid); }
+    inline const QBrush &text() const { return brush(Text); }
+    inline const QBrush &base() const { return brush(Base); }
+    inline const QBrush &alternateBase() const { return brush(AlternateBase); }
+    inline const QBrush &toolTipBase() const { return brush(ToolTipBase); }
+    inline const QBrush &toolTipText() const { return brush(ToolTipText); }
+    inline const QBrush &background() const { return brush(Window); }
+    inline const QBrush &window() const { return brush(Window); }
+    inline const QBrush &midlight() const { return brush(Midlight); }
+    inline const QBrush &brightText() const { return brush(BrightText); }
+    inline const QBrush &buttonText() const { return brush(ButtonText); }
+    inline const QBrush &shadow() const { return brush(Shadow); }
+    inline const QBrush &highlight() const { return brush(Highlight); }
+    inline const QBrush &highlightedText() const { return brush(HighlightedText); }
+    inline const QBrush &link() const { return brush(Link); }
+    inline const QBrush &linkVisited() const { return brush(LinkVisited); }
+# 150 "/usr/include/qt4/QtGui/qpalette.h"
+    bool operator==(const QPalette &p) const;
+    inline bool operator!=(const QPalette &p) const { return !(operator==(p)); }
+    bool isCopyOf(const QPalette &p) const;
+
+    int serialNumber() const;
+    qint64 cacheKey() const;
+
+    QPalette resolve(const QPalette &) const;
+    inline uint resolve() const { return resolve_mask; }
+    inline void resolve(uint mask) { resolve_mask = mask; }
+
+private:
+    void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button,
+                       const QBrush &light, const QBrush &dark, const QBrush &mid,
+                       const QBrush &text, const QBrush &bright_text,
+                       const QBrush &base, const QBrush &alternate_base,
+                       const QBrush &window, const QBrush &midlight,
+                       const QBrush &button_text, const QBrush &shadow,
+                       const QBrush &highlight, const QBrush &highlighted_text,
+                       const QBrush &link, const QBrush &link_visited);
+    void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button,
+                       const QBrush &light, const QBrush &dark, const QBrush &mid,
+                       const QBrush &text, const QBrush &bright_text,
+                       const QBrush &base, const QBrush &alternate_base,
+                       const QBrush &window, const QBrush &midlight,
+                       const QBrush &button_text, const QBrush &shadow,
+                       const QBrush &highlight, const QBrush &highlighted_text,
+                       const QBrush &link, const QBrush &link_visited,
+                       const QBrush &toolTipBase, const QBrush &toolTipText);
+
+
+
+
+
+    void init();
+    void detach();
+
+    QPalettePrivate *d;
+    uint current_group : 4;
+    uint resolve_mask : 28;
+    friend QDataStream &operator<<(QDataStream &s, const QPalette &p);
+};
+
+inline void QPalette::setColor(ColorGroup acg, ColorRole acr,
+                               const QColor &acolor)
+{ setBrush(acg, acr, QBrush(acolor)); }
+inline void QPalette::setColor(ColorRole acr, const QColor &acolor)
+{ setColor(All, acr, acolor); }
+inline void QPalette::setBrush(ColorRole acr, const QBrush &abrush)
+{ setBrush(All, acr, abrush); }
+# 254 "/usr/include/qt4/QtGui/qpalette.h"
+ QDataStream &operator<<(QDataStream &ds, const QPalette &p);
+ QDataStream &operator>>(QDataStream &ds, QPalette &p);
+
+
+
+
+
+# 50 "/usr/include/qt4/QtGui/qwidget.h" 2
+# 1 "/usr/include/qt4/QtGui/qfont.h" 1
+# 50 "/usr/include/qt4/QtGui/qfont.h"
+typedef struct FT_FaceRec_* FT_Face;
+
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QFontPrivate;
+class QStringList;
+class QVariant;
+class Q3TextFormatCollection;
+
+class QFont
+{
+    public: static const QMetaObject staticMetaObject; private:
+   
+public:
+    enum StyleHint {
+        Helvetica, SansSerif = Helvetica,
+        Times, Serif = Times,
+        Courier, TypeWriter = Courier,
+        OldEnglish, Decorative = OldEnglish,
+        System,
+        AnyStyle
+    };
+
+    enum StyleStrategy {
+        PreferDefault = 0x0001,
+        PreferBitmap = 0x0002,
+        PreferDevice = 0x0004,
+        PreferOutline = 0x0008,
+        ForceOutline = 0x0010,
+        PreferMatch = 0x0020,
+        PreferQuality = 0x0040,
+        PreferAntialias = 0x0080,
+        NoAntialias = 0x0100,
+        OpenGLCompatible = 0x0200,
+        NoFontMerging = 0x8000
+    };
+
+    enum Weight {
+        Light = 25,
+        Normal = 50,
+        DemiBold = 63,
+        Bold = 75,
+        Black = 87
+    };
+
+    enum Style {
+        StyleNormal,
+        StyleItalic,
+        StyleOblique
+    };
+
+    enum Stretch {
+        UltraCondensed = 50,
+        ExtraCondensed = 62,
+        Condensed = 75,
+        SemiCondensed = 87,
+        Unstretched = 100,
+        SemiExpanded = 112,
+        Expanded = 125,
+        ExtraExpanded = 150,
+        UltraExpanded = 200
+    };
+
+    enum Capitalization {
+        MixedCase,
+        AllUppercase,
+        AllLowercase,
+        SmallCaps,
+        Capitalize
+    };
+
+    enum SpacingType {
+        PercentageSpacing,
+        AbsoluteSpacing
+    };
+
+    enum ResolveProperties {
+        FamilyResolved = 0x0001,
+        SizeResolved = 0x0002,
+        StyleHintResolved = 0x0004,
+        StyleStrategyResolved = 0x0008,
+        WeightResolved = 0x0010,
+        StyleResolved = 0x0020,
+        UnderlineResolved = 0x0040,
+        OverlineResolved = 0x0080,
+        StrikeOutResolved = 0x0100,
+        FixedPitchResolved = 0x0200,
+        StretchResolved = 0x0400,
+        KerningResolved = 0x0800,
+        CapitalizationResolved = 0x1000,
+        LetterSpacingResolved = 0x2000,
+        WordSpacingResolved = 0x4000,
+        AllPropertiesResolved = 0x7fff
+    };
+
+    QFont();
+    QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false);
+    QFont(const QFont &, QPaintDevice *pd);
+    QFont(const QFont &);
+    ~QFont();
+
+    QString family() const;
+    void setFamily(const QString &);
+
+    int pointSize() const;
+    void setPointSize(int);
+    qreal pointSizeF() const;
+    void setPointSizeF(qreal);
+
+    int pixelSize() const;
+    void setPixelSize(int);
+
+    int weight() const;
+    void setWeight(int);
+
+    inline bool bold() const;
+    inline void setBold(bool);
+
+    void setStyle(Style style);
+    Style style() const;
+
+    inline bool italic() const;
+    inline void setItalic(bool b);
+
+    bool underline() const;
+    void setUnderline(bool);
+
+    bool overline() const;
+    void setOverline(bool);
+
+    bool strikeOut() const;
+    void setStrikeOut(bool);
+
+    bool fixedPitch() const;
+    void setFixedPitch(bool);
+
+    bool kerning() const;
+    void setKerning(bool);
+
+    StyleHint styleHint() const;
+    StyleStrategy styleStrategy() const;
+    void setStyleHint(StyleHint, StyleStrategy = PreferDefault);
+    void setStyleStrategy(StyleStrategy s);
+
+    int stretch() const;
+    void setStretch(int);
+
+    qreal letterSpacing() const;
+    SpacingType letterSpacingType() const;
+    void setLetterSpacing(SpacingType type, qreal spacing);
+
+    qreal wordSpacing() const;
+    void setWordSpacing(qreal spacing);
+
+    void setCapitalization(Capitalization);
+    Capitalization capitalization() const;
+
+
+    bool rawMode() const;
+    void setRawMode(bool);
+
+
+    bool exactMatch() const;
+
+    QFont &operator=(const QFont &);
+    bool operator==(const QFont &) const;
+    bool operator!=(const QFont &) const;
+    bool operator<(const QFont &) const;
+    operator QVariant() const;
+    bool isCopyOf(const QFont &) const;
+
+
+
+
+
+    Qt::HANDLE handle() const;
+
+
+
+
+
+    FT_Face freetypeFace() const;
+
+
+
+    void setRawName(const QString &);
+    QString rawName() const;
+
+    QString key() const;
+
+    QString toString() const;
+    bool fromString(const QString &);
+
+    static QString substitute(const QString &);
+    static QStringList substitutes(const QString &);
+    static QStringList substitutions();
+    static void insertSubstitution(const QString&, const QString &);
+    static void insertSubstitutions(const QString&, const QStringList &);
+    static void removeSubstitution(const QString &);
+    static void initialize();
+    static void cleanup();
+
+    static void cacheStatistics();
+
+
+    QString defaultFamily() const;
+    QString lastResortFamily() const;
+    QString lastResortFont() const;
+
+    QFont resolve(const QFont &) const;
+    inline uint resolve() const { return resolve_mask; }
+    inline void resolve(uint mask) { resolve_mask = mask; }
+# 276 "/usr/include/qt4/QtGui/qfont.h"
+private:
+    QFont(QFontPrivate *);
+
+    void detach();
+
+
+
+
+    void x11SetScreen(int screen = -1);
+    int x11Screen() const;
+
+
+    friend class QFontPrivate;
+    friend class QFontDialogPrivate;
+    friend class QFontMetrics;
+    friend class QFontMetricsF;
+    friend class QFontInfo;
+    friend class QPainter;
+    friend class QPSPrintEngineFont;
+    friend class QApplication;
+    friend class QWidget;
+    friend class QWidgetPrivate;
+    friend class Q3TextFormatCollection;
+    friend class QTextLayout;
+    friend class QTextEngine;
+    friend class QStackTextEngine;
+    friend class QTextLine;
+    friend struct QScriptLine;
+    friend class QGLContext;
+    friend class QWin32PaintEngine;
+    friend class QAlphaPaintEngine;
+    friend class QPainterPath;
+    friend class QTextItemInt;
+    friend class QPicturePaintEngine;
+    friend class QPainterReplayer;
+    friend class QPaintBufferEngine;
+    friend class QCommandLinkButtonPrivate;
+
+
+    friend QDataStream &operator<<(QDataStream &, const QFont &);
+    friend QDataStream &operator>>(QDataStream &, QFont &);
+
+
+    QExplicitlySharedDataPointer<QFontPrivate> d;
+    uint resolve_mask;
+};
+
+
+inline bool QFont::bold() const
+{ return weight() > Normal; }
+
+
+inline void QFont::setBold(bool enable)
+{ setWeight(enable ? Bold : Normal); }
+
+inline bool QFont::italic() const
+{
+    return (style() != StyleNormal);
+}
+
+inline void QFont::setItalic(bool b) {
+    setStyle(b ? StyleItalic : StyleNormal);
+}
+
+
+
+
+
+
+
+ QDataStream &operator<<(QDataStream &, const QFont &);
+ QDataStream &operator>>(QDataStream &, QFont &);
+
+
+
+ QDebug operator<<(QDebug, const QFont &);
+
+
+
+
+
+# 51 "/usr/include/qt4/QtGui/qwidget.h" 2
+# 1 "/usr/include/qt4/QtGui/qfontmetrics.h" 1
+# 51 "/usr/include/qt4/QtGui/qfontmetrics.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+
+
+
+
+class QTextCodec;
+class QRect;
+
+
+class QFontMetrics
+{
+public:
+    QFontMetrics(const QFont &);
+    QFontMetrics(const QFont &, QPaintDevice *pd);
+    QFontMetrics(const QFontMetrics &);
+    ~QFontMetrics();
+
+    QFontMetrics &operator=(const QFontMetrics &);
+
+    int ascent() const;
+    int descent() const;
+    int height() const;
+    int leading() const;
+    int lineSpacing() const;
+    int minLeftBearing() const;
+    int minRightBearing() const;
+    int maxWidth() const;
+
+    int xHeight() const;
+    int averageCharWidth() const;
+
+    bool inFont(QChar) const;
+
+    int leftBearing(QChar) const;
+    int rightBearing(QChar) const;
+    int width(const QString &, int len = -1) const;
+
+    int width(QChar) const;
+    int charWidth(const QString &str, int pos) const;
+
+    QRect boundingRect(QChar) const;
+
+    QRect boundingRect(const QString &text) const;
+    QRect boundingRect(const QRect &r, int flags, const QString &text, int tabstops=0, int *tabarray=0) const;
+    inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text,
+                              int tabstops=0, int *tabarray=0) const
+        { return boundingRect(QRect(x, y, w, h), flags, text, tabstops, tabarray); }
+    QSize size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const;
+
+    QRect tightBoundingRect(const QString &text) const;
+
+    QString elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags = 0) const;
+
+    int underlinePos() const;
+    int overlinePos() const;
+    int strikeOutPos() const;
+    int lineWidth() const;
+
+    bool operator==(const QFontMetrics &other);
+    bool operator==(const QFontMetrics &other) const;
+    inline bool operator !=(const QFontMetrics &other) { return !operator==(other); }
+    inline bool operator !=(const QFontMetrics &other) const { return !operator==(other); }
+# 128 "/usr/include/qt4/QtGui/qfontmetrics.h"
+private:
+
+
+
+    friend class QFontMetricsF;
+    friend class QStackTextEngine;
+
+    QExplicitlySharedDataPointer<QFontPrivate> d;
+};
+
+
+class QFontMetricsF
+{
+public:
+    QFontMetricsF(const QFont &);
+    QFontMetricsF(const QFont &, QPaintDevice *pd);
+    QFontMetricsF(const QFontMetrics &);
+    QFontMetricsF(const QFontMetricsF &);
+    ~QFontMetricsF();
+
+    QFontMetricsF &operator=(const QFontMetricsF &);
+    QFontMetricsF &operator=(const QFontMetrics &);
+
+    qreal ascent() const;
+    qreal descent() const;
+    qreal height() const;
+    qreal leading() const;
+    qreal lineSpacing() const;
+    qreal minLeftBearing() const;
+    qreal minRightBearing() const;
+    qreal maxWidth() const;
+
+    qreal xHeight() const;
+    qreal averageCharWidth() const;
+
+    bool inFont(QChar) const;
+
+    qreal leftBearing(QChar) const;
+    qreal rightBearing(QChar) const;
+    qreal width(const QString &string) const;
+
+    qreal width(QChar) const;
+
+    QRectF boundingRect(const QString &string) const;
+    QRectF boundingRect(QChar) const;
+    QRectF boundingRect(const QRectF &r, int flags, const QString& string, int tabstops=0, int *tabarray=0) const;
+    QSizeF size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const;
+
+    QRectF tightBoundingRect(const QString &text) const;
+
+    QString elidedText(const QString &text, Qt::TextElideMode mode, qreal width, int flags = 0) const;
+
+    qreal underlinePos() const;
+    qreal overlinePos() const;
+    qreal strikeOutPos() const;
+    qreal lineWidth() const;
+
+    bool operator==(const QFontMetricsF &other);
+    bool operator==(const QFontMetricsF &other) const;
+    inline bool operator !=(const QFontMetricsF &other) { return !operator==(other); }
+    inline bool operator !=(const QFontMetricsF &other) const { return !operator==(other); }
+
+private:
+    QExplicitlySharedDataPointer<QFontPrivate> d;
+};
+
+
+
+
+# 52 "/usr/include/qt4/QtGui/qwidget.h" 2
+# 1 "/usr/include/qt4/QtGui/qfontinfo.h" 1
+# 48 "/usr/include/qt4/QtGui/qfontinfo.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QFontInfo
+{
+public:
+    QFontInfo(const QFont &);
+    QFontInfo(const QFontInfo &);
+    ~QFontInfo();
+
+    QFontInfo &operator=(const QFontInfo &);
+
+    QString family() const;
+    int pixelSize() const;
+    int pointSize() const;
+    qreal pointSizeF() const;
+    bool italic() const;
+    QFont::Style style() const;
+    int weight() const;
+    inline bool bold() const { return weight() > QFont::Normal; }
+    bool underline() const;
+    bool overline() const;
+    bool strikeOut() const;
+    bool fixedPitch() const;
+    QFont::StyleHint styleHint() const;
+    bool rawMode() const;
+
+    bool exactMatch() const;
+
+private:
+    QExplicitlySharedDataPointer<QFontPrivate> d;
+};
+
+
+
+
+# 53 "/usr/include/qt4/QtGui/qwidget.h" 2
+# 1 "/usr/include/qt4/QtGui/qsizepolicy.h" 1
+# 47 "/usr/include/qt4/QtGui/qsizepolicy.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QVariant;
+
+class QSizePolicy
+{
+    public: static const QMetaObject staticMetaObject; private:
+   
+
+private:
+    enum SizePolicyMasks {
+        HSize = 4,
+        HMask = 0x0f,
+        VMask = HMask << HSize,
+  CTShift = 9,
+  CTSize = 5,
+                WFHShift = CTShift + CTSize,
+  CTMask = ((0x1 << CTSize) - 1) << CTShift,
+  UnusedShift = CTShift + CTSize,
+  UnusedSize = 2
+    };
+
+public:
+    enum PolicyFlag {
+        GrowFlag = 1,
+        ExpandFlag = 2,
+        ShrinkFlag = 4,
+        IgnoreFlag = 8
+    };
+
+    enum Policy {
+        Fixed = 0,
+        Minimum = GrowFlag,
+        Maximum = ShrinkFlag,
+        Preferred = GrowFlag | ShrinkFlag,
+        MinimumExpanding = GrowFlag | ExpandFlag,
+        Expanding = GrowFlag | ShrinkFlag | ExpandFlag,
+        Ignored = ShrinkFlag | GrowFlag | IgnoreFlag
+    };
+
+    enum ControlType {
+        DefaultType = 0x00000001,
+        ButtonBox = 0x00000002,
+        CheckBox = 0x00000004,
+        ComboBox = 0x00000008,
+        Frame = 0x00000010,
+        GroupBox = 0x00000020,
+        Label = 0x00000040,
+        Line = 0x00000080,
+        LineEdit = 0x00000100,
+        PushButton = 0x00000200,
+        RadioButton = 0x00000400,
+        Slider = 0x00000800,
+        SpinBox = 0x00001000,
+        TabWidget = 0x00002000,
+        ToolButton = 0x00004000
+    };
+    typedef QFlags<ControlType> ControlTypes;
+
+    QSizePolicy() : data(0) { }
+
+
+    QSizePolicy(Policy horizontal, Policy vertical)
+        : data(horizontal | (vertical << HSize)) { }
+    QSizePolicy(Policy horizontal, Policy vertical, ControlType type)
+        : data(horizontal | (vertical << HSize)) { setControlType(type); }
+
+    Policy horizontalPolicy() const { return static_cast<Policy>(data & HMask); }
+    Policy verticalPolicy() const { return static_cast<Policy>((data & VMask) >> HSize); }
+    ControlType controlType() const;
+
+    void setHorizontalPolicy(Policy d) { data = (data & ~HMask) | d; }
+    void setVerticalPolicy(Policy d) { data = (data & ~(HMask << HSize)) | (d << HSize); }
+    void setControlType(ControlType type);
+
+    Qt::Orientations expandingDirections() const {
+        Qt::Orientations result;
+        if (verticalPolicy() & ExpandFlag)
+            result |= Qt::Vertical;
+        if (horizontalPolicy() & ExpandFlag)
+            result |= Qt::Horizontal;
+        return result;
+    }
+
+    void setHeightForWidth(bool b) { data = b ? (data | (1 << 2*HSize)) : (data & ~(1 << 2*HSize)); }
+    bool hasHeightForWidth() const { return data & (1 << 2*HSize); }
+
+    bool operator==(const QSizePolicy& s) const { return data == s.data; }
+    bool operator!=(const QSizePolicy& s) const { return data != s.data; }
+    operator QVariant() const;
+
+    int horizontalStretch() const { return data >> 24; }
+    int verticalStretch() const { return (data >> 16) & 0xff; }
+    void setHorizontalStretch(uchar stretchFactor) { data = (data&0x00ffffff) | (uint(stretchFactor)<<24); }
+    void setVerticalStretch(uchar stretchFactor) { data = (data&0xff00ffff) | (uint(stretchFactor)<<16); }
+
+    void transpose();
+# 195 "/usr/include/qt4/QtGui/qsizepolicy.h"
+private:
+
+    friend QDataStream &operator<<(QDataStream &, const QSizePolicy &);
+    friend QDataStream &operator>>(QDataStream &, QSizePolicy &);
+
+    QSizePolicy(int i) : data(i) { }
+
+    quint32 data;
+# 214 "/usr/include/qt4/QtGui/qsizepolicy.h"
+};
+
+inline QFlags<QSizePolicy::ControlTypes::enum_type> operator|(QSizePolicy::ControlTypes::enum_type f1, QSizePolicy::ControlTypes::enum_type f2) { return QFlags<QSizePolicy::ControlTypes::enum_type>(f1) | f2; } inline QFlags<QSizePolicy::ControlTypes::enum_type> operator|(QSizePolicy::ControlTypes::enum_type f1, QFlags<QSizePolicy::ControlTypes::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QSizePolicy::ControlTypes::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+
+
+
+ QDataStream &operator<<(QDataStream &, const QSizePolicy &);
+ QDataStream &operator>>(QDataStream &, QSizePolicy &);
+
+
+inline void QSizePolicy::transpose() {
+    Policy hData = horizontalPolicy();
+    Policy vData = verticalPolicy();
+    uchar hStretch = uchar(horizontalStretch());
+    uchar vStretch = uchar(verticalStretch());
+    setHorizontalPolicy(vData);
+    setVerticalPolicy(hData);
+    setHorizontalStretch(vStretch);
+    setVerticalStretch(hStretch);
+}
+
+
+
+
+# 54 "/usr/include/qt4/QtGui/qwidget.h" 2
+
+
+# 1 "/usr/include/qt4/QtGui/qcursor.h" 1
+# 48 "/usr/include/qt4/QtGui/qcursor.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QVariant;
+# 75 "/usr/include/qt4/QtGui/qcursor.h"
+class QCursorData;
+class QBitmap;
+class QPixmap;
+# 89 "/usr/include/qt4/QtGui/qcursor.h"
+class QCursor
+{
+public:
+    QCursor();
+    QCursor(Qt::CursorShape shape);
+    QCursor(const QBitmap &bitmap, const QBitmap &mask, int hotX=-1, int hotY=-1);
+    QCursor(const QPixmap &pixmap, int hotX=-1, int hotY=-1);
+    QCursor(const QCursor &cursor);
+    ~QCursor();
+    QCursor &operator=(const QCursor &cursor);
+    operator QVariant() const;
+
+    Qt::CursorShape shape() const;
+    void setShape(Qt::CursorShape newShape);
+
+    const QBitmap *bitmap() const;
+    const QBitmap *mask() const;
+    QPixmap pixmap() const;
+    QPoint hotSpot() const;
+
+    static QPoint pos();
+    static void setPos(int x, int y);
+    inline static void setPos(const QPoint &p) { setPos(p.x(), p.y()); }
+# 124 "/usr/include/qt4/QtGui/qcursor.h"
+    Qt::HANDLE handle() const;
+    QCursor(Qt::HANDLE cursor);
+    static int x11Screen();
+# 136 "/usr/include/qt4/QtGui/qcursor.h"
+private:
+    QCursorData *d;
+# 148 "/usr/include/qt4/QtGui/qcursor.h"
+};
+# 166 "/usr/include/qt4/QtGui/qcursor.h"
+ QDataStream &operator<<(QDataStream &outS, const QCursor &cursor);
+ QDataStream &operator>>(QDataStream &inS, QCursor &cursor);
+
+
+
+
+
+
+# 57 "/usr/include/qt4/QtGui/qwidget.h" 2
+# 1 "/usr/include/qt4/QtGui/qkeysequence.h" 1
+# 48 "/usr/include/qt4/QtGui/qkeysequence.h"
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+
+
+
+
+
+
+class QKeySequence;
+ QDataStream &operator<<(QDataStream &in, const QKeySequence &ks);
+ QDataStream &operator>>(QDataStream &out, QKeySequence &ks);
+
+
+
+
+
+
+class QVariant;
+class QKeySequencePrivate;
+
+class QKeySequence
+{
+public:
+    enum StandardKey {
+        UnknownKey,
+        HelpContents,
+        WhatsThis,
+        Open,
+        Close,
+        Save,
+        New,
+        Delete,
+        Cut,
+        Copy,
+        Paste,
+        Undo,
+        Redo,
+        Back,
+        Forward,
+        Refresh,
+        ZoomIn,
+        ZoomOut,
+        Print,
+        AddTab,
+        NextChild,
+        PreviousChild,
+        Find,
+        FindNext,
+        FindPrevious,
+        Replace,
+        SelectAll,
+        Bold,
+        Italic,
+        Underline,
+        MoveToNextChar,
+        MoveToPreviousChar,
+        MoveToNextWord,
+        MoveToPreviousWord,
+        MoveToNextLine,
+        MoveToPreviousLine,
+        MoveToNextPage,
+        MoveToPreviousPage,
+        MoveToStartOfLine,
+        MoveToEndOfLine,
+        MoveToStartOfBlock,
+        MoveToEndOfBlock,
+        MoveToStartOfDocument,
+        MoveToEndOfDocument,
+        SelectNextChar,
+        SelectPreviousChar,
+        SelectNextWord,
+        SelectPreviousWord,
+        SelectNextLine,
+        SelectPreviousLine,
+        SelectNextPage,
+        SelectPreviousPage,
+        SelectStartOfLine,
+        SelectEndOfLine,
+        SelectStartOfBlock,
+        SelectEndOfBlock,
+        SelectStartOfDocument,
+        SelectEndOfDocument,
+        DeleteStartOfWord,
+        DeleteEndOfWord,
+        DeleteEndOfLine,
+        InsertParagraphSeparator,
+        InsertLineSeparator,
+        SaveAs,
+        Preferences,
+        Quit
+     };
+
+    QKeySequence();
+    QKeySequence(const QString &key);
+    QKeySequence(int k1, int k2 = 0, int k3 = 0, int k4 = 0);
+    QKeySequence(const QKeySequence &ks);
+    QKeySequence(StandardKey key);
+    ~QKeySequence();
+
+    uint count() const;
+    bool isEmpty() const;
+
+    enum SequenceMatch {
+        NoMatch,
+        PartialMatch,
+        ExactMatch
+
+
+
+    };
+
+    enum SequenceFormat {
+        NativeText,
+        PortableText
+    };
+
+    QString toString(SequenceFormat format = PortableText) const;
+    static QKeySequence fromString(const QString &str, SequenceFormat format = PortableText);
+
+    SequenceMatch matches(const QKeySequence &seq) const;
+    static QKeySequence mnemonic(const QString &text);
+    static QList<QKeySequence> keyBindings(StandardKey key);
+
+
+    operator QString() const;
+    operator QVariant() const;
+    operator int() const;
+    int operator[](uint i) const;
+    QKeySequence &operator=(const QKeySequence &other);
+    bool operator==(const QKeySequence &other) const;
+    inline bool operator!= (const QKeySequence &other) const
+    { return !(*this == other); }
+    bool operator< (const QKeySequence &ks) const;
+    inline bool operator> (const QKeySequence &other) const
+    { return other < *this; }
+    inline bool operator<= (const QKeySequence &other) const
+    { return !(other < *this); }
+    inline bool operator>= (const QKeySequence &other) const
+    { return !(*this < other); }
+
+    bool isDetached() const;
+private:
+    static int decodeString(const QString &ks);
+    static QString encodeString(int key);
+    int assign(const QString &str);
+    void setKey(int key, int index);
+
+    QKeySequencePrivate *d;
+
+    friend QDataStream &operator<<(QDataStream &in, const QKeySequence &ks);
+    friend QDataStream &operator>>(QDataStream &in, QKeySequence &ks);
+    friend class Q3AccelManager;
+    friend class QShortcutMap;
+    friend class QShortcut;
+
+public:
+    typedef QKeySequencePrivate * DataPtr;
+    inline DataPtr &data_ptr() { return d; }
+};
+template <> class QTypeInfo<QKeySequence > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QKeySequence)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QKeySequence"; } };
+template <> inline bool qIsDetached<QKeySequence>(QKeySequence &t) { return t.isDetached(); } template <> inline void qSwap<QKeySequence>(QKeySequence &value1, QKeySequence &value2) { qSwap(value1.data_ptr(), value2.data_ptr()); }
+
+
+ QDebug operator<<(QDebug, const QKeySequence &);
+# 229 "/usr/include/qt4/QtGui/qkeysequence.h"
+
+
+
+# 58 "/usr/include/qt4/QtGui/qwidget.h" 2
+
+
+
+
+
+
+
+
+
+typedef QtValidLicenseForGuiModule QtGuiModule;
+
+class QLayout;
+class QWSRegionManager;
+class QStyle;
+class QAction;
+class QVariant;
+
+class QActionEvent;
+class QMouseEvent;
+class QWheelEvent;
+class QHoverEvent;
+class QKeyEvent;
+class QFocusEvent;
+class QPaintEvent;
+class QMoveEvent;
+class QResizeEvent;
+class QCloseEvent;
+class QContextMenuEvent;
+class QInputMethodEvent;
+class QTabletEvent;
+class QDragEnterEvent;
+class QDragMoveEvent;
+class QDragLeaveEvent;
+class QDropEvent;
+class QShowEvent;
+class QHideEvent;
+class QInputContext;
+class QIcon;
+class QWindowSurface;
+class QLocale;
+class QGraphicsProxyWidget;
+class QGraphicsEffect;
+
+class QX11Info;
+
+
+class QWidgetData
+{
+public:
+    WId winid;
+    uint widget_attributes;
+    Qt::WindowFlags window_flags;
+    uint window_state : 4;
+    uint focus_policy : 4;
+    uint sizehint_forced :1;
+    uint is_closing :1;
+    uint in_show : 1;
+    uint in_set_window_state : 1;
+    mutable uint fstrut_dirty : 1;
+    uint context_menu_policy : 3;
+    uint window_modality : 2;
+    uint in_destructor : 1;
+    uint unused : 13;
+    QRect crect;
+    mutable QPalette pal;
+    QFont fnt;
+# 135 "/usr/include/qt4/QtGui/qwidget.h"
+    QRect wrect;
+};
+
+class QWidgetPrivate;
+
+class QWidget : public QObject, public QPaintDevice
+{
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private:
+    inline QWidgetPrivate* d_func() { return reinterpret_cast<QWidgetPrivate *>(qGetPtrHelper(d_ptr)); } inline const QWidgetPrivate* d_func() const { return reinterpret_cast<const QWidgetPrivate *>(qGetPtrHelper(d_ptr)); } friend class QWidgetPrivate;
+
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+
+   
+
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+   
+
+   
+
+
+   
+
+
+   
+
+
+
+
+
+   
+   
+   
+
+   
+
+   
+   
+   
+
+public:
+    enum RenderFlag {
+        DrawWindowBackground = 0x1,
+        DrawChildren = 0x2,
+        IgnoreMask = 0x4
+    };
+    typedef QFlags<RenderFlag> RenderFlags;
+
+    explicit QWidget(QWidget* parent = 0, Qt::WindowFlags f = 0);
+
+
+
+    ~QWidget();
+
+    int devType() const;
+
+    WId winId() const;
+    void createWinId();
+    inline WId internalWinId() const { return data->winid; }
+    WId effectiveWinId() const;
+
+
+    QStyle *style() const;
+    void setStyle(QStyle *);
+
+
+    bool isTopLevel() const;
+    bool isWindow() const;
+
+    bool isModal() const;
+    Qt::WindowModality windowModality() const;
+    void setWindowModality(Qt::WindowModality windowModality);
+
+    bool isEnabled() const;
+    bool isEnabledTo(QWidget*) const;
+    bool isEnabledToTLW() const;
+
+public :
+    void setEnabled(bool);
+    void setDisabled(bool);
+    void setWindowModified(bool);
+
+
+
+public:
+    QRect frameGeometry() const;
+    const QRect &geometry() const;
+    QRect normalGeometry() const;
+
+    int x() const;
+    int y() const;
+    QPoint pos() const;
+    QSize frameSize() const;
+    QSize size() const;
+    inline int width() const;
+    inline int height() const;
+    inline QRect rect() const;
+    QRect childrenRect() const;
+    QRegion childrenRegion() const;
+
+    QSize minimumSize() const;
+    QSize maximumSize() const;
+    int minimumWidth() const;
+    int minimumHeight() const;
+    int maximumWidth() const;
+    int maximumHeight() const;
+    void setMinimumSize(const QSize &);
+    void setMinimumSize(int minw, int minh);
+    void setMaximumSize(const QSize &);
+    void setMaximumSize(int maxw, int maxh);
+    void setMinimumWidth(int minw);
+    void setMinimumHeight(int minh);
+    void setMaximumWidth(int maxw);
+    void setMaximumHeight(int maxh);
+
+
+
+
+
+    QSize sizeIncrement() const;
+    void setSizeIncrement(const QSize &);
+    void setSizeIncrement(int w, int h);
+    QSize baseSize() const;
+    void setBaseSize(const QSize &);
+    void setBaseSize(int basew, int baseh);
+
+    void setFixedSize(const QSize &);
+    void setFixedSize(int w, int h);
+    void setFixedWidth(int w);
+    void setFixedHeight(int h);
+
+
+
+    QPoint mapToGlobal(const QPoint &) const;
+    QPoint mapFromGlobal(const QPoint &) const;
+    QPoint mapToParent(const QPoint &) const;
+    QPoint mapFromParent(const QPoint &) const;
+    QPoint mapTo(QWidget *, const QPoint &) const;
+    QPoint mapFrom(QWidget *, const QPoint &) const;
+
+    QWidget *window() const;
+    QWidget *nativeParentWidget() const;
+    inline QWidget *topLevelWidget() const { return window(); }
+
+
+    const QPalette &palette() const;
+    void setPalette(const QPalette &);
+
+    void setBackgroundRole(QPalette::ColorRole);
+    QPalette::ColorRole backgroundRole() const;
+
+    void setForegroundRole(QPalette::ColorRole);
+    QPalette::ColorRole foregroundRole() const;
+
+    const QFont &font() const;
+    void setFont(const QFont &);
+    QFontMetrics fontMetrics() const;
+    QFontInfo fontInfo() const;
+
+
+    QCursor cursor() const;
+    void setCursor(const QCursor &);
+    void unsetCursor();
+
+
+    void setMouseTracking(bool enable);
+    bool hasMouseTracking() const;
+    bool underMouse() const;
+
+    void setMask(const QBitmap &);
+    void setMask(const QRegion &);
+    QRegion mask() const;
+    void clearMask();
+
+    void render(QPaintDevice *target, const QPoint &targetOffset = QPoint(),
+                const QRegion &sourceRegion = QRegion(),
+                RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren));
+
+    void render(QPainter *painter, const QPoint &targetOffset = QPoint(),
+                const QRegion &sourceRegion = QRegion(),
+                RenderFlags renderFlags = RenderFlags(DrawWindowBackground | DrawChildren));
+
+
+    QGraphicsEffect *graphicsEffect() const;
+    void setGraphicsEffect(QGraphicsEffect *effect);
+
+
+    void grabGesture(Qt::GestureType type, Qt::GestureFlags flags = Qt::GestureFlags());
+    void ungrabGesture(Qt::GestureType type);
+
+public :
+    void setWindowTitle(const QString &);
+
+    void setStyleSheet(const QString& styleSheet);
+
+public:
+
+    QString styleSheet() const;
+
+    QString windowTitle() const;
+    void setWindowIcon(const QIcon &icon);
+    QIcon windowIcon() const;
+    void setWindowIconText(const QString &);
+    QString windowIconText() const;
+    void setWindowRole(const QString &);
+    QString windowRole() const;
+    void setWindowFilePath(const QString &filePath);
+    QString windowFilePath() const;
+
+    void setWindowOpacity(qreal level);
+    qreal windowOpacity() const;
+
+    bool isWindowModified() const;
+
+    void setToolTip(const QString &);
+    QString toolTip() const;
+
+
+    void setStatusTip(const QString &);
+    QString statusTip() const;
+
+
+    void setWhatsThis(const QString &);
+    QString whatsThis() const;
+# 408 "/usr/include/qt4/QtGui/qwidget.h"
+    void setLayoutDirection(Qt::LayoutDirection direction);
+    Qt::LayoutDirection layoutDirection() const;
+    void unsetLayoutDirection();
+
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+    void unsetLocale();
+
+    inline bool isRightToLeft() const { return layoutDirection() == Qt::RightToLeft; }
+    inline bool isLeftToRight() const { return layoutDirection() == Qt::LeftToRight; }
+
+public :
+    inline void setFocus() { setFocus(Qt::OtherFocusReason); }
+
+public:
+    bool isActiveWindow() const;
+    void activateWindow();
+    void clearFocus();
+
+    void setFocus(Qt::FocusReason reason);
+    Qt::FocusPolicy focusPolicy() const;
+    void setFocusPolicy(Qt::FocusPolicy policy);
+    bool hasFocus() const;
+    static void setTabOrder(QWidget *, QWidget *);
+    void setFocusProxy(QWidget *);
+    QWidget *focusProxy() const;
+    Qt::ContextMenuPolicy contextMenuPolicy() const;
+    void setContextMenuPolicy(Qt::ContextMenuPolicy policy);
+
+
+    void grabMouse();
+
+    void grabMouse(const QCursor &);
+
+    void releaseMouse();
+    void grabKeyboard();
+    void releaseKeyboard();
+
+    int grabShortcut(const QKeySequence &key, Qt::ShortcutContext context = Qt::WindowShortcut);
+    void releaseShortcut(int id);
+    void setShortcutEnabled(int id, bool enable = true);
+    void setShortcutAutoRepeat(int id, bool enable = true);
+
+    static QWidget *mouseGrabber();
+    static QWidget *keyboardGrabber();
+
+
+    inline bool updatesEnabled() const;
+    void setUpdatesEnabled(bool enable);
+
+
+
+
+
+
+    QGraphicsProxyWidget *graphicsProxyWidget() const;
+
+
+public :
+    void update();
+    void repaint();
+
+public:
+    inline void update(int x, int y, int w, int h);
+    void update(const QRect&);
+    void update(const QRegion&);
+
+    void repaint(int x, int y, int w, int h);
+    void repaint(const QRect &);
+    void repaint(const QRegion &);
+
+public :
+
+
+    virtual void setVisible(bool visible);
+    inline void setHidden(bool hidden) { setVisible(!hidden); }
+
+    inline void show() { setVisible(true); }
+
+
+
+    inline void hide() { setVisible(false); }
+    inline void setShown(bool shown) { setVisible(shown); }
+
+    void showMinimized();
+    void showMaximized();
+    void showFullScreen();
+    void showNormal();
+
+    bool close();
+    void raise();
+    void lower();
+
+public:
+    void stackUnder(QWidget*);
+    void move(int x, int y);
+    void move(const QPoint &);
+    void resize(int w, int h);
+    void resize(const QSize &);
+    inline void setGeometry(int x, int y, int w, int h);
+    void setGeometry(const QRect &);
+    QByteArray saveGeometry() const;
+    bool restoreGeometry(const QByteArray &geometry);
+    void adjustSize();
+    bool isVisible() const;
+    bool isVisibleTo(QWidget*) const;
+
+    inline bool isHidden() const;
+
+    bool isMinimized() const;
+    bool isMaximized() const;
+    bool isFullScreen() const;
+
+    Qt::WindowStates windowState() const;
+    void setWindowState(Qt::WindowStates state);
+    void overrideWindowState(Qt::WindowStates state);
+
+    virtual QSize sizeHint() const;
+    virtual QSize minimumSizeHint() const;
+
+    QSizePolicy sizePolicy() const;
+    void setSizePolicy(QSizePolicy);
+    inline void setSizePolicy(QSizePolicy::Policy horizontal, QSizePolicy::Policy vertical);
+    virtual int heightForWidth(int) const;
+
+    QRegion visibleRegion() const;
+
+    void setContentsMargins(int left, int top, int right, int bottom);
+    void setContentsMargins(const QMargins &margins);
+    void getContentsMargins(int *left, int *top, int *right, int *bottom) const;
+    QMargins contentsMargins() const;
+
+    QRect contentsRect() const;
+
+public:
+    QLayout *layout() const;
+    void setLayout(QLayout *);
+    void updateGeometry();
+
+    void setParent(QWidget *parent);
+    void setParent(QWidget *parent, Qt::WindowFlags f);
+
+    void scroll(int dx, int dy);
+    void scroll(int dx, int dy, const QRect&);
+
+
+
+    QWidget *focusWidget() const;
+    QWidget *nextInFocusChain() const;
+    QWidget *previousInFocusChain() const;
+
+
+    bool acceptDrops() const;
+    void setAcceptDrops(bool on);
+
+
+
+    void addAction(QAction *action);
+    void addActions(QList<QAction*> actions);
+    void insertAction(QAction *before, QAction *action);
+    void insertActions(QAction *before, QList<QAction*> actions);
+    void removeAction(QAction *action);
+    QList<QAction*> actions() const;
+
+
+    QWidget *parentWidget() const;
+
+    void setWindowFlags(Qt::WindowFlags type);
+    inline Qt::WindowFlags windowFlags() const;
+    void overrideWindowFlags(Qt::WindowFlags type);
+
+    inline Qt::WindowType windowType() const;
+
+    static QWidget *find(WId);
+
+
+
+    inline QWidget *childAt(int x, int y) const;
+    QWidget *childAt(const QPoint &p) const;
+
+
+    const QX11Info &x11Info() const;
+    Qt::HANDLE x11PictureHandle() const;
+# 602 "/usr/include/qt4/QtGui/qwidget.h"
+    Qt::HANDLE handle() const;
+
+
+    void setAttribute(Qt::WidgetAttribute, bool on = true);
+    inline bool testAttribute(Qt::WidgetAttribute) const;
+
+    QPaintEngine *paintEngine() const;
+
+    void ensurePolished() const;
+
+    QInputContext *inputContext();
+    void setInputContext(QInputContext *);
+
+    bool isAncestorOf(const QWidget *child) const;
+
+
+
+
+
+
+    bool autoFillBackground() const;
+    void setAutoFillBackground(bool enabled);
+
+    void setWindowSurface(QWindowSurface *surface);
+    QWindowSurface *windowSurface() const;
+
+public:
+    void customContextMenuRequested(const QPoint &pos);
+
+public:
+
+    bool event(QEvent *);
+    virtual void mousePressEvent(QMouseEvent *);
+    virtual void mouseReleaseEvent(QMouseEvent *);
+    virtual void mouseDoubleClickEvent(QMouseEvent *);
+    virtual void mouseMoveEvent(QMouseEvent *);
+
+    virtual void wheelEvent(QWheelEvent *);
+
+    virtual void keyPressEvent(QKeyEvent *);
+    virtual void keyReleaseEvent(QKeyEvent *);
+    virtual void focusInEvent(QFocusEvent *);
+    virtual void focusOutEvent(QFocusEvent *);
+    virtual void enterEvent(QEvent *);
+    virtual void leaveEvent(QEvent *);
+    virtual void paintEvent(QPaintEvent *);
+    virtual void moveEvent(QMoveEvent *);
+    virtual void resizeEvent(QResizeEvent *);
+    virtual void closeEvent(QCloseEvent *);
+
+    virtual void contextMenuEvent(QContextMenuEvent *);
+
+
+    virtual void tabletEvent(QTabletEvent *);
+
+
+    virtual void actionEvent(QActionEvent *);
+
+
+
+    virtual void dragEnterEvent(QDragEnterEvent *);
+    virtual void dragMoveEvent(QDragMoveEvent *);
+    virtual void dragLeaveEvent(QDragLeaveEvent *);
+    virtual void dropEvent(QDropEvent *);
+
+
+    virtual void showEvent(QShowEvent *);
+    virtual void hideEvent(QHideEvent *);
+# 678 "/usr/include/qt4/QtGui/qwidget.h"
+    virtual bool x11Event(XEvent *);
+
+
+
+
+
+
+    virtual void changeEvent(QEvent *);
+
+    int metric(PaintDeviceMetric) const;
+
+    virtual void inputMethodEvent(QInputMethodEvent *);
+public:
+    virtual QVariant inputMethodQuery(Qt::InputMethodQuery) const;
+
+    Qt::InputMethodHints inputMethodHints() const;
+    void setInputMethodHints(Qt::InputMethodHints hints);
+
+public:
+    void resetInputContext();
+public :
+    void updateMicroFocus();
+public:
+
+    void create(WId = 0, bool initializeWindow = true,
+                         bool destroyOldWindow = true);
+    void destroy(bool destroyWindow = true,
+                 bool destroySubWindows = true);
+
+    virtual bool focusNextPrevChild(bool next);
+    inline bool focusNextChild() { return focusNextPrevChild(true); }
+    inline bool focusPreviousChild() { return focusNextPrevChild(false); }
+
+public:
+    QWidget(QWidgetPrivate &d, QWidget* parent, Qt::WindowFlags f);
+private:
+
+    bool testAttribute_helper(Qt::WidgetAttribute) const;
+
+    QLayout *takeLayout();
+
+    friend class QBackingStoreDevice;
+    friend class QWidgetBackingStore;
+    friend class QApplication;
+    friend class QApplicationPrivate;
+    friend class QBaseApplication;
+    friend class QPainter;
+    friend class QPainterPrivate;
+    friend class QPixmap;
+    friend class QFontMetrics;
+    friend class QFontInfo;
+    friend class QETWidget;
+    friend class QLayout;
+    friend class QWidgetItem;
+    friend class QWidgetItemV2;
+    friend class QGLContext;
+    friend class QGLWidget;
+    friend class QGLWindowSurface;
+    friend class QX11PaintEngine;
+    friend class QWin32PaintEngine;
+    friend class QShortcutPrivate;
+    friend class QShortcutMap;
+    friend class QWindowSurface;
+    friend class QGraphicsProxyWidget;
+    friend class QGraphicsProxyWidgetPrivate;
+    friend class QStyleSheetStyle;
+    friend struct QWidgetExceptionCleaner;
+    friend class QGestureManager;
+    friend class QWinNativePanGestureRecognizer;
+    friend class QWidgetEffectSourcePrivate;
+# 774 "/usr/include/qt4/QtGui/qwidget.h"
+    friend void qt_net_update_user_time(QWidget *tlw, unsigned long timestamp);
+    friend void qt_net_remove_user_time(QWidget *tlw);
+
+
+    friend QWidgetData *qt_qwidget_data(QWidget *widget);
+    friend QWidgetPrivate *qt_widget_private(QWidget *widget);
+
+private:
+    QWidget(const QWidget &); QWidget &operator=(const QWidget &);
+   
+
+
+
+
+    QWidgetData *data;
+# 885 "/usr/include/qt4/QtGui/qwidget.h"
+public:
+    virtual void styleChange(QStyle&);
+    virtual void enabledChange(bool);
+    virtual void paletteChange(const QPalette &);
+    virtual void fontChange(const QFont &);
+    virtual void windowActivationChange(bool);
+    virtual void languageChange();
+};
+
+inline QFlags<QWidget::RenderFlags::enum_type> operator|(QWidget::RenderFlags::enum_type f1, QWidget::RenderFlags::enum_type f2) { return QFlags<QWidget::RenderFlags::enum_type>(f1) | f2; } inline QFlags<QWidget::RenderFlags::enum_type> operator|(QWidget::RenderFlags::enum_type f1, QFlags<QWidget::RenderFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QWidget::RenderFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+# 903 "/usr/include/qt4/QtGui/qwidget.h"
+template <> inline QWidget *qobject_cast<QWidget*>(QObject *o)
+{
+    if (!o || !o->isWidgetType()) return 0;
+    return static_cast<QWidget*>(o);
+}
+template <> inline const QWidget *qobject_cast<const QWidget*>(const QObject *o)
+{
+    if (!o || !o->isWidgetType()) return 0;
+    return static_cast<const QWidget*>(o);
+}
+
+
+inline QWidget *QWidget::childAt(int ax, int ay) const
+{ return childAt(QPoint(ax, ay)); }
+
+inline Qt::WindowType QWidget::windowType() const
+{ return static_cast<Qt::WindowType>(int(data->window_flags & Qt::WindowType_Mask)); }
+inline Qt::WindowFlags QWidget::windowFlags() const
+{ return data->window_flags; }
+
+inline bool QWidget::isTopLevel() const
+{ return (windowType() & Qt::Window); }
+
+inline bool QWidget::isWindow() const
+{ return (windowType() & Qt::Window); }
+
+inline bool QWidget::isEnabled() const
+{ return !testAttribute(Qt::WA_Disabled); }
+
+inline bool QWidget::isModal() const
+{ return data->window_modality != Qt::NonModal; }
+
+inline bool QWidget::isEnabledToTLW() const
+{ return isEnabled(); }
+
+inline int QWidget::minimumWidth() const
+{ return minimumSize().width(); }
+
+inline int QWidget::minimumHeight() const
+{ return minimumSize().height(); }
+
+inline int QWidget::maximumWidth() const
+{ return maximumSize().width(); }
+
+inline int QWidget::maximumHeight() const
+{ return maximumSize().height(); }
+
+inline void QWidget::setMinimumSize(const QSize &s)
+{ setMinimumSize(s.width(),s.height()); }
+
+inline void QWidget::setMaximumSize(const QSize &s)
+{ setMaximumSize(s.width(),s.height()); }
+
+inline void QWidget::setSizeIncrement(const QSize &s)
+{ setSizeIncrement(s.width(),s.height()); }
+
+inline void QWidget::setBaseSize(const QSize &s)
+{ setBaseSize(s.width(),s.height()); }
+
+inline const QFont &QWidget::font() const
+{ return data->fnt; }
+
+inline QFontMetrics QWidget::fontMetrics() const
+{ return QFontMetrics(data->fnt); }
+
+inline QFontInfo QWidget::fontInfo() const
+{ return QFontInfo(data->fnt); }
+
+inline void QWidget::setMouseTracking(bool enable)
+{ setAttribute(Qt::WA_MouseTracking, enable); }
+
+inline bool QWidget::hasMouseTracking() const
+{ return testAttribute(Qt::WA_MouseTracking); }
+
+inline bool QWidget::underMouse() const
+{ return testAttribute(Qt::WA_UnderMouse); }
+
+inline bool QWidget::updatesEnabled() const
+{ return !testAttribute(Qt::WA_UpdatesDisabled); }
+
+inline void QWidget::update(int ax, int ay, int aw, int ah)
+{ update(QRect(ax, ay, aw, ah)); }
+
+inline bool QWidget::isVisible() const
+{ return testAttribute(Qt::WA_WState_Visible); }
+
+inline bool QWidget::isHidden() const
+{ return testAttribute(Qt::WA_WState_Hidden); }
+
+inline void QWidget::move(int ax, int ay)
+{ move(QPoint(ax, ay)); }
+
+inline void QWidget::resize(int w, int h)
+{ resize(QSize(w, h)); }
+
+inline void QWidget::setGeometry(int ax, int ay, int aw, int ah)
+{ setGeometry(QRect(ax, ay, aw, ah)); }
+
+inline QRect QWidget::rect() const
+{ return QRect(0,0,data->crect.width(),data->crect.height()); }
+
+inline const QRect &QWidget::geometry() const
+{ return data->crect; }
+
+inline QSize QWidget::size() const
+{ return data->crect.size(); }
+
+inline int QWidget::width() const
+{ return data->crect.width(); }
+
+inline int QWidget::height() const
+{ return data->crect.height(); }
+
+inline QWidget *QWidget::parentWidget() const
+{ return static_cast<QWidget *>(QObject::parent()); }
+
+inline void QWidget::setSizePolicy(QSizePolicy::Policy hor, QSizePolicy::Policy ver)
+{ setSizePolicy(QSizePolicy(hor, ver)); }
+
+inline bool QWidget::testAttribute(Qt::WidgetAttribute attribute) const
+{
+    if (attribute < int(8*sizeof(uint)))
+        return data->widget_attributes & (1<<attribute);
+    return testAttribute_helper(attribute);
+}
+# 1070 "/usr/include/qt4/QtGui/qwidget.h"
+
+
+
+# 30 "/usr/include/qt4/QtWebKit/qwebpage.h" 2
+
+
+class QNetworkProxy;
+class QUndoStack;
+class QMenu;
+class QNetworkRequest;
+class QNetworkReply;
+class QNetworkAccessManager;
+
+
+class QWebElement;
+class QWebFrame;
+class QWebNetworkRequest;
+class QWebHistory;
+
+class QWebPagePrivate;
+class QWebFrameData;
+class QWebNetworkInterface;
+class QWebPluginFactory;
+class QWebHitTestResult;
+class QWebHistoryItem;
+
+namespace WebCore {
+    class ChromeClientQt;
+    class EditorClientQt;
+    class FrameLoaderClientQt;
+    class InspectorClientQt;
+    class ResourceHandle;
+    class HitTestResult;
+    class QNetworkReplyHandler;
+
+    struct FrameLoadRequest;
+}
+
+class QWebPage : public QObject {
+    public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private:
+
+   
+   
+   
+   
+   
+   
+   
+   
+   
+public:
+    enum NavigationType {
+        NavigationTypeLinkClicked,
+        NavigationTypeFormSubmitted,
+        NavigationTypeBackOrForward,
+        NavigationTypeReload,
+        NavigationTypeFormResubmitted,
+        NavigationTypeOther
+    };
+
+    enum WebAction {
+        NoWebAction = - 1,
+
+        OpenLink,
+
+        OpenLinkInNewWindow,
+        OpenFrameInNewWindow,
+
+        DownloadLinkToDisk,
+        CopyLinkToClipboard,
+
+        OpenImageInNewWindow,
+        DownloadImageToDisk,
+        CopyImageToClipboard,
+
+        Back,
+        Forward,
+        Stop,
+        Reload,
+
+        Cut,
+        Copy,
+        Paste,
+
+        Undo,
+        Redo,
+        MoveToNextChar,
+        MoveToPreviousChar,
+        MoveToNextWord,
+        MoveToPreviousWord,
+        MoveToNextLine,
+        MoveToPreviousLine,
+        MoveToStartOfLine,
+        MoveToEndOfLine,
+        MoveToStartOfBlock,
+        MoveToEndOfBlock,
+        MoveToStartOfDocument,
+        MoveToEndOfDocument,
+        SelectNextChar,
+        SelectPreviousChar,
+        SelectNextWord,
+        SelectPreviousWord,
+        SelectNextLine,
+        SelectPreviousLine,
+        SelectStartOfLine,
+        SelectEndOfLine,
+        SelectStartOfBlock,
+        SelectEndOfBlock,
+        SelectStartOfDocument,
+        SelectEndOfDocument,
+        DeleteStartOfWord,
+        DeleteEndOfWord,
+
+        SetTextDirectionDefault,
+        SetTextDirectionLeftToRight,
+        SetTextDirectionRightToLeft,
+
+        ToggleBold,
+        ToggleItalic,
+        ToggleUnderline,
+
+        InspectElement,
+
+        InsertParagraphSeparator,
+        InsertLineSeparator,
+
+        SelectAll,
+        ReloadAndBypassCache,
+
+        PasteAndMatchStyle,
+        RemoveFormat,
+
+        ToggleStrikethrough,
+        ToggleSubscript,
+        ToggleSuperscript,
+        InsertUnorderedList,
+        InsertOrderedList,
+        Indent,
+        Outdent,
+
+        AlignCenter,
+        AlignJustified,
+        AlignLeft,
+        AlignRight,
+
+        WebActionCount
+    };
+
+    enum FindFlag {
+        FindBackward = 1,
+        FindCaseSensitively = 2,
+        FindWrapsAroundDocument = 4,
+        HighlightAllOccurrences = 8
+    };
+    typedef QFlags<FindFlag> FindFlags;
+
+    enum LinkDelegationPolicy {
+        DontDelegateLinks,
+        DelegateExternalLinks,
+        DelegateAllLinks
+    };
+
+    enum WebWindowType {
+        WebBrowserWindow,
+        WebModalDialog
+    };
+
+    explicit QWebPage(QObject *parent = 0);
+    ~QWebPage();
+
+    QWebFrame *mainFrame() const;
+    QWebFrame *currentFrame() const;
+    QWebFrame* frameAt(const QPoint& pos) const;
+
+    QWebHistory *history() const;
+    QWebSettings *settings() const;
+
+    void setView(QWidget *view);
+    QWidget *view() const;
+
+    bool isModified() const;
+
+    QUndoStack *undoStack() const;
+# 222 "/usr/include/qt4/QtWebKit/qwebpage.h"
+    void setNetworkAccessManager(QNetworkAccessManager *manager);
+    QNetworkAccessManager *networkAccessManager() const;
+
+
+    void setPluginFactory(QWebPluginFactory *factory);
+    QWebPluginFactory *pluginFactory() const;
+
+    quint64 totalBytes() const;
+    quint64 bytesReceived() const;
+
+    QString selectedText() const;
+
+    QAction *action(WebAction action) const;
+    virtual void triggerAction(WebAction action, bool checked = false);
+
+    QSize viewportSize() const;
+    void setViewportSize(const QSize &size) const;
+
+    QSize preferredContentsSize() const;
+    void setPreferredContentsSize(const QSize &size) const;
+
+    virtual bool event(QEvent*);
+    bool focusNextPrevChild(bool next);
+
+    QVariant inputMethodQuery(Qt::InputMethodQuery property) const;
+
+    bool findText(const QString &subString, FindFlags options = 0);
+
+    void setForwardUnsupportedContent(bool forward);
+    bool forwardUnsupportedContent() const;
+
+    void setLinkDelegationPolicy(LinkDelegationPolicy policy);
+    LinkDelegationPolicy linkDelegationPolicy() const;
+
+    void setPalette(const QPalette &palette);
+    QPalette palette() const;
+
+    void setContentEditable(bool editable);
+    bool isContentEditable() const;
+
+
+    bool swallowContextMenuEvent(QContextMenuEvent *event);
+
+    void updatePositionDependentActions(const QPoint &pos);
+
+    QMenu *createStandardContextMenu();
+
+    enum Extension {
+        ChooseMultipleFilesExtension,
+        ErrorPageExtension
+    };
+    class ExtensionOption
+    {};
+    class ExtensionReturn
+    {};
+
+    class ChooseMultipleFilesExtensionOption : public ExtensionOption {
+    public:
+        QWebFrame *parentFrame;
+        QStringList suggestedFileNames;
+    };
+
+    class ChooseMultipleFilesExtensionReturn : public ExtensionReturn {
+    public:
+        QStringList fileNames;
+    };
+
+    enum ErrorDomain { QtNetwork, Http, WebKit };
+    class ErrorPageExtensionOption : public ExtensionOption {
+    public:
+        QUrl url;
+        QWebFrame* frame;
+        ErrorDomain domain;
+        int error;
+        QString errorString;
+    };
+
+    class ErrorPageExtensionReturn : public ExtensionReturn {
+    public:
+        ErrorPageExtensionReturn() : contentType(QLatin1String("text/html")), encoding(QLatin1String("utf-8")) {};
+        QString contentType;
+        QString encoding;
+        QUrl baseUrl;
+        QByteArray content;
+    };
+
+
+    virtual bool extension(Extension extension, const ExtensionOption *option = 0, ExtensionReturn *output = 0);
+    virtual bool supportsExtension(Extension extension) const;
+
+    inline QWebPagePrivate* handle() const { return d; }
+
+public :
+    bool shouldInterruptJavaScript();
+
+public:
+    void loadStarted();
+    void loadProgress(int progress);
+    void loadFinished(bool ok);
+
+    void linkHovered(const QString &link, const QString &title, const QString &textContent);
+    void statusBarMessage(const QString& text);
+    void selectionChanged();
+    void frameCreated(QWebFrame *frame);
+    void geometryChangeRequested(const QRect& geom);
+    void repaintRequested(const QRect& dirtyRect);
+    void scrollRequested(int dx, int dy, const QRect& scrollViewRect);
+    void windowCloseRequested();
+    void printRequested(QWebFrame *frame);
+    void linkClicked(const QUrl &url);
+
+    void toolBarVisibilityChangeRequested(bool visible);
+    void statusBarVisibilityChangeRequested(bool visible);
+    void menuBarVisibilityChangeRequested(bool visible);
+
+
+    void unsupportedContent(QNetworkReply *reply);
+    void downloadRequested(const QNetworkRequest &request);
+
+
+    void microFocusChanged();
+    void contentsChanged();
+    void databaseQuotaExceeded(QWebFrame* frame, QString databaseName);
+
+    void saveFrameStateRequested(QWebFrame* frame, QWebHistoryItem* item);
+    void restoreFrameStateRequested(QWebFrame* frame);
+
+public:
+    virtual QWebPage *createWindow(WebWindowType type);
+    virtual QObject *createPlugin(const QString &classid, const QUrl &url, const QStringList &paramNames, const QStringList &paramValues);
+
+
+    virtual bool acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, NavigationType type);
+
+
+
+    virtual QString chooseFile(QWebFrame *originatingFrame, const QString& oldFile);
+    virtual void javaScriptAlert(QWebFrame *originatingFrame, const QString& msg);
+    virtual bool javaScriptConfirm(QWebFrame *originatingFrame, const QString& msg);
+    virtual bool javaScriptPrompt(QWebFrame *originatingFrame, const QString& msg, const QString& defaultValue, QString* result);
+    virtual void javaScriptConsoleMessage(const QString& message, int lineNumber, const QString& sourceID);
+
+    virtual QString userAgentForUrl(const QUrl& url) const;
+
+private:
+   
+   
+   
+
+    QWebPagePrivate *d;
+
+    friend class QWebFrame;
+    friend class QWebPagePrivate;
+    friend class QWebView;
+    friend class QGraphicsWebView;
+    friend class QWebInspector;
+    friend class WebCore::ChromeClientQt;
+    friend class WebCore::EditorClientQt;
+    friend class WebCore::FrameLoaderClientQt;
+    friend class WebCore::InspectorClientQt;
+    friend class WebCore::ResourceHandle;
+    friend class WebCore::QNetworkReplyHandler;
+};
+
+inline QFlags<QWebPage::FindFlags::enum_type> operator|(QWebPage::FindFlags::enum_type f1, QWebPage::FindFlags::enum_type f2) { return QFlags<QWebPage::FindFlags::enum_type>(f1) | f2; } inline QFlags<QWebPage::FindFlags::enum_type> operator|(QWebPage::FindFlags::enum_type f1, QFlags<QWebPage::FindFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QWebPage::FindFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp" 2
+
+
+
+
+
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 1
+# 26 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp"
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 1
+# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp"
+# 1 "/usr/include/boost-1_42/boost/python.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/args.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 1
+# 50 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
+# 1 "/usr/include/python2.6/pyconfig.h" 1
+# 51 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
+# 61 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/syslimits.h" 1 3 4
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 169 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 3 4
+# 1 "/usr/include/limits.h" 1 3 4
+# 145 "/usr/include/limits.h" 3 4
+# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
+# 157 "/usr/include/bits/posix1_lim.h" 3 4
+# 1 "/usr/include/bits/local_lim.h" 1 3 4
+# 39 "/usr/include/bits/local_lim.h" 3 4
+# 1 "/usr/include/linux/limits.h" 1 3 4
+# 40 "/usr/include/bits/local_lim.h" 2 3 4
+# 158 "/usr/include/bits/posix1_lim.h" 2 3 4
+# 146 "/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
+# 150 "/usr/include/limits.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
+# 34 "/usr/include/bits/xopen_lim.h" 3 4
+# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
+# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
+# 154 "/usr/include/limits.h" 2 3 4
+# 170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 2 3 4
+# 8 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/syslimits.h" 2 3 4
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 2 3 4
+# 62 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
+# 75 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
+# 1 "/usr/include/python2.6/patchlevel.h" 1
+# 76 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
+# 142 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp"
+# 1 "/usr/include/python2.6/Python.h" 1
+
+
+
+
+
+
+# 1 "/usr/include/python2.6/patchlevel.h" 1
+# 8 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/pyconfig.h" 1
+# 9 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/pymacconfig.h" 1
+# 10 "/usr/include/python2.6/Python.h" 2
+# 19 "/usr/include/python2.6/Python.h"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 20 "/usr/include/python2.6/Python.h" 2
+# 33 "/usr/include/python2.6/Python.h"
+# 1 "/usr/include/stdio.h" 1 3 4
+# 30 "/usr/include/stdio.h" 3 4
+extern "C" {
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 35 "/usr/include/stdio.h" 2 3 4
+# 75 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/libio.h" 1 3 4
+# 32 "/usr/include/libio.h" 3 4
+# 1 "/usr/include/_G_config.h" 1 3 4
+# 15 "/usr/include/_G_config.h" 3 4
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 16 "/usr/include/_G_config.h" 2 3 4
+
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 21 "/usr/include/_G_config.h" 2 3 4
+
+typedef struct
+{
+  __off_t __pos;
+  __mbstate_t __state;
+} _G_fpos_t;
+typedef struct
+{
+  __off64_t __pos;
+  __mbstate_t __state;
+} _G_fpos64_t;
+# 53 "/usr/include/_G_config.h" 3 4
+typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
+typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
+typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
+typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
+# 33 "/usr/include/libio.h" 2 3 4
+# 170 "/usr/include/libio.h" 3 4
+struct _IO_jump_t; struct _IO_FILE;
+# 180 "/usr/include/libio.h" 3 4
+typedef void _IO_lock_t;
+
+
+
+
+
+struct _IO_marker {
+  struct _IO_marker *_next;
+  struct _IO_FILE *_sbuf;
+
+
+
+  int _pos;
+# 203 "/usr/include/libio.h" 3 4
+};
+
+
+enum __codecvt_result
+{
+  __codecvt_ok,
+  __codecvt_partial,
+  __codecvt_error,
+  __codecvt_noconv
+};
+# 271 "/usr/include/libio.h" 3 4
+struct _IO_FILE {
+  int _flags;
+
+
+
+
+  char* _IO_read_ptr;
+  char* _IO_read_end;
+  char* _IO_read_base;
+  char* _IO_write_base;
+  char* _IO_write_ptr;
+  char* _IO_write_end;
+  char* _IO_buf_base;
+  char* _IO_buf_end;
+
+  char *_IO_save_base;
+  char *_IO_backup_base;
+  char *_IO_save_end;
+
+  struct _IO_marker *_markers;
+
+  struct _IO_FILE *_chain;
+
+  int _fileno;
+
+
+
+  int _flags2;
+
+  __off_t _old_offset;
+
+
+
+  unsigned short _cur_column;
+  signed char _vtable_offset;
+  char _shortbuf[1];
+
+
+
+  _IO_lock_t *_lock;
+# 319 "/usr/include/libio.h" 3 4
+  __off64_t _offset;
+# 328 "/usr/include/libio.h" 3 4
+  void *__pad1;
+  void *__pad2;
+  void *__pad3;
+  void *__pad4;
+  size_t __pad5;
+
+  int _mode;
+
+  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
+
+};
+
+
+
+
+
+struct _IO_FILE_plus;
+
+extern struct _IO_FILE_plus _IO_2_1_stdin_;
+extern struct _IO_FILE_plus _IO_2_1_stdout_;
+extern struct _IO_FILE_plus _IO_2_1_stderr_;
+# 364 "/usr/include/libio.h" 3 4
+typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
+
+
+
+
+
+
+
+typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
+     size_t __n);
+
+
+
+
+
+
+
+typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
+
+
+typedef int __io_close_fn (void *__cookie);
+
+
+
+
+typedef __io_read_fn cookie_read_function_t;
+typedef __io_write_fn cookie_write_function_t;
+typedef __io_seek_fn cookie_seek_function_t;
+typedef __io_close_fn cookie_close_function_t;
+
+
+typedef struct
+{
+  __io_read_fn *read;
+  __io_write_fn *write;
+  __io_seek_fn *seek;
+  __io_close_fn *close;
+} _IO_cookie_io_functions_t;
+typedef _IO_cookie_io_functions_t cookie_io_functions_t;
+
+struct _IO_cookie_file;
+
+
+extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
+        void *__cookie, _IO_cookie_io_functions_t __fns);
+
+
+
+
+extern "C" {
+
+
+extern int __underflow (_IO_FILE *);
+extern int __uflow (_IO_FILE *);
+extern int __overflow (_IO_FILE *, int);
+# 460 "/usr/include/libio.h" 3 4
+extern int _IO_getc (_IO_FILE *__fp);
+extern int _IO_putc (int __c, _IO_FILE *__fp);
+extern int _IO_feof (_IO_FILE *__fp) throw ();
+extern int _IO_ferror (_IO_FILE *__fp) throw ();
+
+extern int _IO_peekc_locked (_IO_FILE *__fp);
+
+
+
+
+
+extern void _IO_flockfile (_IO_FILE *) throw ();
+extern void _IO_funlockfile (_IO_FILE *) throw ();
+extern int _IO_ftrylockfile (_IO_FILE *) throw ();
+# 490 "/usr/include/libio.h" 3 4
+extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
+   __gnuc_va_list, int *__restrict);
+extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
+    __gnuc_va_list);
+extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
+extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
+
+extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
+extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
+
+extern void _IO_free_backup_area (_IO_FILE *) throw ();
+# 552 "/usr/include/libio.h" 3 4
+}
+# 76 "/usr/include/stdio.h" 2 3 4
+# 89 "/usr/include/stdio.h" 3 4
+
+
+typedef _G_fpos_t fpos_t;
+
+
+
+
+
+typedef _G_fpos64_t fpos64_t;
+# 141 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
+# 142 "/usr/include/stdio.h" 2 3 4
+
+
+
+extern struct _IO_FILE *stdin;
+extern struct _IO_FILE *stdout;
+extern struct _IO_FILE *stderr;
+
+
+
+
+
+
+
+extern int remove (__const char *__filename) throw ();
+
+extern int rename (__const char *__old, __const char *__new) throw ();
+
+
+
+
+extern int renameat (int __oldfd, __const char *__old, int __newfd,
+       __const char *__new) throw ();
+
+
+
+
+
+
+
+
+extern FILE *tmpfile (void) __attribute__ ((__warn_unused_result__));
+# 182 "/usr/include/stdio.h" 3 4
+extern FILE *tmpfile64 (void) __attribute__ ((__warn_unused_result__));
+
+
+
+extern char *tmpnam (char *__s) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern char *tmpnam_r (char *__s) throw () __attribute__ ((__warn_unused_result__));
+# 204 "/usr/include/stdio.h" 3 4
+extern char *tempnam (__const char *__dir, __const char *__pfx)
+     throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+
+extern int fclose (FILE *__stream);
+
+
+
+
+extern int fflush (FILE *__stream);
+
+# 229 "/usr/include/stdio.h" 3 4
+extern int fflush_unlocked (FILE *__stream);
+# 239 "/usr/include/stdio.h" 3 4
+extern int fcloseall (void);
+
+
+
+
+
+
+
+
+
+extern FILE *fopen (__const char *__restrict __filename,
+      __const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern FILE *freopen (__const char *__restrict __filename,
+        __const char *__restrict __modes,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+# 272 "/usr/include/stdio.h" 3 4
+
+
+extern FILE *fopen64 (__const char *__restrict __filename,
+        __const char *__restrict __modes) __attribute__ ((__warn_unused_result__));
+extern FILE *freopen64 (__const char *__restrict __filename,
+   __const char *__restrict __modes,
+   FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern FILE *fdopen (int __fd, __const char *__modes) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern FILE *fopencookie (void *__restrict __magic_cookie,
+     __const char *__restrict __modes,
+     _IO_cookie_io_functions_t __io_funcs) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes)
+  throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
+
+
+
+extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
+      int __modes, size_t __n) throw ();
+
+
+
+
+
+extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
+         size_t __size) throw ();
+
+
+extern void setlinebuf (FILE *__stream) throw ();
+
+
+
+
+
+
+
+
+extern int fprintf (FILE *__restrict __stream,
+      __const char *__restrict __format, ...);
+
+
+
+
+extern int printf (__const char *__restrict __format, ...);
+
+extern int sprintf (char *__restrict __s,
+      __const char *__restrict __format, ...) throw ();
+
+
+
+
+
+extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
+       __gnuc_va_list __arg);
+
+
+
+
+extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);
+
+extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
+       __gnuc_va_list __arg) throw ();
+
+
+
+
+
+extern int snprintf (char *__restrict __s, size_t __maxlen,
+       __const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+
+extern int vsnprintf (char *__restrict __s, size_t __maxlen,
+        __const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+
+
+
+
+
+
+extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
+        __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0))) __attribute__ ((__warn_unused_result__));
+extern int __asprintf (char **__restrict __ptr,
+         __const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
+extern int asprintf (char **__restrict __ptr,
+       __const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3))) __attribute__ ((__warn_unused_result__));
+# 394 "/usr/include/stdio.h" 3 4
+extern int vdprintf (int __fd, __const char *__restrict __fmt,
+       __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 2, 0)));
+extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
+     __attribute__ ((__format__ (__printf__, 2, 3)));
+
+
+
+
+
+
+
+
+extern int fscanf (FILE *__restrict __stream,
+     __const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int scanf (__const char *__restrict __format, ...) __attribute__ ((__warn_unused_result__));
+
+extern int sscanf (__const char *__restrict __s,
+     __const char *__restrict __format, ...) throw ();
+# 445 "/usr/include/stdio.h" 3 4
+
+
+
+
+
+
+
+
+extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
+      __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__scanf__, 1, 0))) __attribute__ ((__warn_unused_result__));
+
+
+extern int vsscanf (__const char *__restrict __s,
+      __const char *__restrict __format, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
+# 504 "/usr/include/stdio.h" 3 4
+
+
+
+
+
+
+
+
+
+extern int fgetc (FILE *__stream);
+extern int getc (FILE *__stream);
+
+
+
+
+
+extern int getchar (void);
+
+# 532 "/usr/include/stdio.h" 3 4
+extern int getc_unlocked (FILE *__stream);
+extern int getchar_unlocked (void);
+# 543 "/usr/include/stdio.h" 3 4
+extern int fgetc_unlocked (FILE *__stream);
+
+
+
+
+
+
+
+
+
+
+
+extern int fputc (int __c, FILE *__stream);
+extern int putc (int __c, FILE *__stream);
+
+
+
+
+
+extern int putchar (int __c);
+
+# 576 "/usr/include/stdio.h" 3 4
+extern int fputc_unlocked (int __c, FILE *__stream);
+
+
+
+
+
+
+
+extern int putc_unlocked (int __c, FILE *__stream);
+extern int putchar_unlocked (int __c);
+
+
+
+
+
+
+extern int getw (FILE *__stream);
+
+
+extern int putw (int __w, FILE *__stream);
+
+
+
+
+
+
+
+
+extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+     __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern char *gets (char *__s) __attribute__ ((__warn_unused_result__));
+
+# 622 "/usr/include/stdio.h" 3 4
+extern char *fgets_unlocked (char *__restrict __s, int __n,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+# 638 "/usr/include/stdio.h" 3 4
+extern __ssize_t __getdelim (char **__restrict __lineptr,
+          size_t *__restrict __n, int __delimiter,
+          FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern __ssize_t getdelim (char **__restrict __lineptr,
+        size_t *__restrict __n, int __delimiter,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+extern __ssize_t getline (char **__restrict __lineptr,
+       size_t *__restrict __n,
+       FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+
+extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);
+
+
+
+
+
+extern int puts (__const char *__s);
+
+
+
+
+
+
+extern int ungetc (int __c, FILE *__stream);
+
+
+
+
+
+
+extern size_t fread (void *__restrict __ptr, size_t __size,
+       size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
+        size_t __n, FILE *__restrict __s) __attribute__ ((__warn_unused_result__));
+
+# 699 "/usr/include/stdio.h" 3 4
+extern int fputs_unlocked (__const char *__restrict __s,
+      FILE *__restrict __stream);
+# 710 "/usr/include/stdio.h" 3 4
+extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
+         size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
+          size_t __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+
+extern int fseek (FILE *__stream, long int __off, int __whence);
+
+
+
+
+extern long int ftell (FILE *__stream) __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern void rewind (FILE *__stream);
+
+# 746 "/usr/include/stdio.h" 3 4
+extern int fseeko (FILE *__stream, __off_t __off, int __whence);
+
+
+
+
+extern __off_t ftello (FILE *__stream) __attribute__ ((__warn_unused_result__));
+# 765 "/usr/include/stdio.h" 3 4
+
+
+
+
+
+
+extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
+
+
+
+
+extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
+# 788 "/usr/include/stdio.h" 3 4
+
+
+
+extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
+extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__warn_unused_result__));
+extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
+extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);
+
+
+
+
+extern void clearerr (FILE *__stream) throw ();
+
+extern int feof (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+
+extern int ferror (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern void clearerr_unlocked (FILE *__stream) throw ();
+extern int feof_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+extern int ferror_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+
+
+extern void perror (__const char *__s);
+
+
+
+
+
+
+# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
+# 27 "/usr/include/bits/sys_errlist.h" 3 4
+extern int sys_nerr;
+extern __const char *__const sys_errlist[];
+
+
+extern int _sys_nerr;
+extern __const char *__const _sys_errlist[];
+# 827 "/usr/include/stdio.h" 2 3 4
+
+
+
+
+extern int fileno (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+
+
+
+
+extern int fileno_unlocked (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+# 846 "/usr/include/stdio.h" 3 4
+extern FILE *popen (__const char *__command, __const char *__modes) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+extern int pclose (FILE *__stream);
+
+
+
+
+
+extern char *ctermid (char *__s) throw ();
+
+
+
+
+
+extern char *cuserid (char *__s);
+
+
+
+
+struct obstack;
+
+
+extern int obstack_printf (struct obstack *__restrict __obstack,
+      __const char *__restrict __format, ...)
+     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
+extern int obstack_vprintf (struct obstack *__restrict __obstack,
+       __const char *__restrict __format,
+       __gnuc_va_list __args)
+     throw () __attribute__ ((__format__ (__printf__, 2, 0)));
+
+
+
+
+
+
+
+extern void flockfile (FILE *__stream) throw ();
+
+
+
+extern int ftrylockfile (FILE *__stream) throw () __attribute__ ((__warn_unused_result__));
+
+
+extern void funlockfile (FILE *__stream) throw ();
+# 907 "/usr/include/stdio.h" 3 4
+# 1 "/usr/include/bits/stdio.h" 1 3 4
+# 44 "/usr/include/bits/stdio.h" 3 4
+extern __inline __attribute__ ((__gnu_inline__)) int
+getchar (void)
+{
+  return _IO_getc (stdin);
+}
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+fgetc_unlocked (FILE *__fp)
+{
+  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
+}
+
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+getc_unlocked (FILE *__fp)
+{
+  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+getchar_unlocked (void)
+{
+  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
+}
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+putchar (int __c)
+{
+  return _IO_putc (__c, stdout);
+}
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+fputc_unlocked (int __c, FILE *__stream)
+{
+  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
+}
+
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+putc_unlocked (int __c, FILE *__stream)
+{
+  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+putchar_unlocked (int __c)
+{
+  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
+}
+
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
+getline (char **__lineptr, size_t *__n, FILE *__stream)
+{
+  return __getdelim (__lineptr, __n, '\n', __stream);
+}
+
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+feof_unlocked (FILE *__stream) throw ()
+{
+  return (((__stream)->_flags & 0x10) != 0);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+ferror_unlocked (FILE *__stream) throw ()
+{
+  return (((__stream)->_flags & 0x20) != 0);
+}
+# 908 "/usr/include/stdio.h" 2 3 4
+
+
+# 1 "/usr/include/bits/stdio2.h" 1 3 4
+# 24 "/usr/include/bits/stdio2.h" 3 4
+extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
+     __const char *__restrict __format, ...) throw ();
+extern int __vsprintf_chk (char *__restrict __s, int __flag, size_t __slen,
+      __const char *__restrict __format,
+      __gnuc_va_list __ap) throw ();
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+sprintf (char *__restrict __s, __const char *__restrict __fmt, ...) throw ()
+{
+  return __builtin___sprintf_chk (__s, 2 - 1,
+      __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
+}
+
+
+
+
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vsprintf (char *__restrict __s, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+
+{
+  return __builtin___vsprintf_chk (__s, 2 - 1,
+       __builtin_object_size (__s, 2 > 1), __fmt, __ap);
+}
+
+
+
+extern int __snprintf_chk (char *__restrict __s, size_t __n, int __flag,
+      size_t __slen, __const char *__restrict __format,
+      ...) throw ();
+extern int __vsnprintf_chk (char *__restrict __s, size_t __n, int __flag,
+       size_t __slen, __const char *__restrict __format,
+       __gnuc_va_list __ap) throw ();
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+snprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, ...) throw ()
+
+{
+  return __builtin___snprintf_chk (__s, __n, 2 - 1,
+       __builtin_object_size (__s, 2 > 1), __fmt, __builtin_va_arg_pack ());
+}
+
+
+
+
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vsnprintf (char *__restrict __s, size_t __n, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+
+{
+  return __builtin___vsnprintf_chk (__s, __n, 2 - 1,
+        __builtin_object_size (__s, 2 > 1), __fmt, __ap);
+}
+
+
+
+
+
+extern int __fprintf_chk (FILE *__restrict __stream, int __flag,
+     __const char *__restrict __format, ...);
+extern int __printf_chk (int __flag, __const char *__restrict __format, ...);
+extern int __vfprintf_chk (FILE *__restrict __stream, int __flag,
+      __const char *__restrict __format, __gnuc_va_list __ap);
+extern int __vprintf_chk (int __flag, __const char *__restrict __format,
+     __gnuc_va_list __ap);
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+fprintf (FILE *__restrict __stream, __const char *__restrict __fmt, ...)
+{
+  return __fprintf_chk (__stream, 2 - 1, __fmt,
+   __builtin_va_arg_pack ());
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+printf (__const char *__restrict __fmt, ...)
+{
+  return __printf_chk (2 - 1, __fmt, __builtin_va_arg_pack ());
+}
+
+
+
+
+
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vprintf (__const char *__restrict __fmt, __gnuc_va_list __ap)
+{
+
+  return __vfprintf_chk (stdout, 2 - 1, __fmt, __ap);
+
+
+
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vfprintf (FILE *__restrict __stream,
+   __const char *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vfprintf_chk (__stream, 2 - 1, __fmt, __ap);
+}
+
+
+
+extern int __asprintf_chk (char **__restrict __ptr, int __flag,
+      __const char *__restrict __fmt, ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4))) __attribute__ ((__warn_unused_result__));
+extern int __vasprintf_chk (char **__restrict __ptr, int __flag,
+       __const char *__restrict __fmt, __gnuc_va_list __arg)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0))) __attribute__ ((__warn_unused_result__));
+extern int __dprintf_chk (int __fd, int __flag, __const char *__restrict __fmt,
+     ...) __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int __vdprintf_chk (int __fd, int __flag,
+      __const char *__restrict __fmt, __gnuc_va_list __arg)
+     __attribute__ ((__format__ (__printf__, 3, 0)));
+extern int __obstack_printf_chk (struct obstack *__restrict __obstack,
+     int __flag, __const char *__restrict __format,
+     ...)
+     throw () __attribute__ ((__format__ (__printf__, 3, 4)));
+extern int __obstack_vprintf_chk (struct obstack *__restrict __obstack,
+      int __flag,
+      __const char *__restrict __format,
+      __gnuc_va_list __args)
+     throw () __attribute__ ((__format__ (__printf__, 3, 0)));
+
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()
+{
+  return __asprintf_chk (__ptr, 2 - 1, __fmt,
+    __builtin_va_arg_pack ());
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+__asprintf (char **__restrict __ptr, __const char *__restrict __fmt, ...) throw ()
+
+{
+  return __asprintf_chk (__ptr, 2 - 1, __fmt,
+    __builtin_va_arg_pack ());
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+dprintf (int __fd, __const char *__restrict __fmt, ...)
+{
+  return __dprintf_chk (__fd, 2 - 1, __fmt,
+   __builtin_va_arg_pack ());
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+obstack_printf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, ...) throw ()
+
+{
+  return __obstack_printf_chk (__obstack, 2 - 1, __fmt,
+          __builtin_va_arg_pack ());
+}
+# 195 "/usr/include/bits/stdio2.h" 3 4
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vasprintf (char **__restrict __ptr, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+
+{
+  return __vasprintf_chk (__ptr, 2 - 1, __fmt, __ap);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+vdprintf (int __fd, __const char *__restrict __fmt, __gnuc_va_list __ap)
+{
+  return __vdprintf_chk (__fd, 2 - 1, __fmt, __ap);
+}
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) int
+obstack_vprintf (struct obstack *__restrict __obstack, __const char *__restrict __fmt, __gnuc_va_list __ap) throw ()
+
+{
+  return __obstack_vprintf_chk (__obstack, 2 - 1, __fmt,
+    __ap);
+}
+
+
+
+
+
+extern char *__gets_chk (char *__str, size_t) __attribute__ ((__warn_unused_result__));
+extern char *__gets_warn (char *__str) __asm__ ("" "gets")
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("please use fgets or getline instead, gets can't " "specify buffer size")))
+                               ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+gets (char *__str)
+{
+  if (__builtin_object_size (__str, 2 > 1) != (size_t) -1)
+    return __gets_chk (__str, __builtin_object_size (__str, 2 > 1));
+  return __gets_warn (__str);
+}
+
+extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
+     FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern char *__fgets_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets")
+
+                                        __attribute__ ((__warn_unused_result__));
+extern char *__fgets_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_chk")
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets called with bigger size than length " "of destination buffer")))
+                                 ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgets_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
+ return __fgets_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+    }
+  return __fgets_alias (__s, __n, __stream);
+}
+
+extern size_t __fread_chk (void *__restrict __ptr, size_t __ptrlen,
+      size_t __size, size_t __n,
+      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern size_t __fread_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread")
+
+
+            __attribute__ ((__warn_unused_result__));
+extern size_t __fread_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_chk")
+
+
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread called with bigger size * nmemb than length " "of destination buffer")))
+                                 ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
+fread (void *__restrict __ptr, size_t __size, size_t __n,
+       FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size)
+   || !__builtin_constant_p (__n)
+   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
+ return __fread_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
+
+      if (__size * __n > __builtin_object_size (__ptr, 0))
+ return __fread_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n, __stream);
+    }
+  return __fread_alias (__ptr, __size, __n, __stream);
+}
+
+
+extern char *__fgets_unlocked_chk (char *__restrict __s, size_t __size,
+       int __n, FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern char *__fgets_unlocked_alias (char *__restrict __s, int __n, FILE *__restrict __stream) __asm__ ("" "fgets_unlocked")
+
+                                                 __attribute__ ((__warn_unused_result__));
+extern char *__fgets_unlocked_chk_warn (char *__restrict __s, size_t __size, int __n, FILE *__restrict __stream) __asm__ ("" "__fgets_unlocked_chk")
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fgets_unlocked called with bigger size than length " "of destination buffer")))
+                                 ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) char *
+fgets_unlocked (char *__restrict __s, int __n, FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__s, 2 > 1) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__n) || __n <= 0)
+ return __fgets_unlocked_chk (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+
+      if ((size_t) __n > __builtin_object_size (__s, 2 > 1))
+ return __fgets_unlocked_chk_warn (__s, __builtin_object_size (__s, 2 > 1), __n, __stream);
+    }
+  return __fgets_unlocked_alias (__s, __n, __stream);
+}
+
+
+
+
+extern size_t __fread_unlocked_chk (void *__restrict __ptr, size_t __ptrlen,
+        size_t __size, size_t __n,
+        FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
+extern size_t __fread_unlocked_alias (void *__restrict __ptr, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "fread_unlocked")
+
+
+                     __attribute__ ((__warn_unused_result__));
+extern size_t __fread_unlocked_chk_warn (void *__restrict __ptr, size_t __ptrlen, size_t __size, size_t __n, FILE *__restrict __stream) __asm__ ("" "__fread_unlocked_chk")
+
+
+
+
+     __attribute__ ((__warn_unused_result__)) __attribute__((__warning__ ("fread_unlocked called with bigger size * nmemb than " "length of destination buffer")))
+                                        ;
+
+extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__, __artificial__)) __attribute__ ((__warn_unused_result__)) size_t
+fread_unlocked (void *__restrict __ptr, size_t __size, size_t __n,
+  FILE *__restrict __stream)
+{
+  if (__builtin_object_size (__ptr, 0) != (size_t) -1)
+    {
+      if (!__builtin_constant_p (__size)
+   || !__builtin_constant_p (__n)
+   || (__size | __n) >= (((size_t) 1) << (8 * sizeof (size_t) / 2)))
+ return __fread_unlocked_chk (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
+         __stream);
+
+      if (__size * __n > __builtin_object_size (__ptr, 0))
+ return __fread_unlocked_chk_warn (__ptr, __builtin_object_size (__ptr, 0), __size, __n,
+       __stream);
+    }
+
+
+  if (__builtin_constant_p (__size)
+      && __builtin_constant_p (__n)
+      && (__size | __n) < (((size_t) 1) << (8 * sizeof (size_t) / 2))
+      && __size * __n <= 8)
+    {
+      size_t __cnt = __size * __n;
+      char *__cptr = (char *) __ptr;
+      if (__cnt == 0)
+ return 0;
+
+      for (; __cnt > 0; --__cnt)
+ {
+   int __c = (__builtin_expect (((__stream)->_IO_read_ptr >= (__stream)->_IO_read_end), 0) ? __uflow (__stream) : *(unsigned char *) (__stream)->_IO_read_ptr++);
+   if (__c == (-1))
+     break;
+   *__cptr++ = __c;
+ }
+      return (__cptr - (char *) __ptr) / __size;
+    }
+
+  return __fread_unlocked_alias (__ptr, __size, __n, __stream);
+}
+# 911 "/usr/include/stdio.h" 2 3 4
+
+
+
+
+
+}
+# 34 "/usr/include/python2.6/Python.h" 2
+
+
+
+
+
+
+# 1 "/usr/include/errno.h" 1 3 4
+# 32 "/usr/include/errno.h" 3 4
+extern "C" {
+
+
+
+# 1 "/usr/include/bits/errno.h" 1 3 4
+# 25 "/usr/include/bits/errno.h" 3 4
+# 1 "/usr/include/linux/errno.h" 1 3 4
+
+
+
+# 1 "/usr/include/asm/errno.h" 1 3 4
+# 1 "/usr/include/asm-generic/errno.h" 1 3 4
+
+
+
+# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
+# 5 "/usr/include/asm-generic/errno.h" 2 3 4
+# 1 "/usr/include/asm/errno.h" 2 3 4
+# 5 "/usr/include/linux/errno.h" 2 3 4
+# 26 "/usr/include/bits/errno.h" 2 3 4
+# 43 "/usr/include/bits/errno.h" 3 4
+extern int *__errno_location (void) throw () __attribute__ ((__const__));
+# 37 "/usr/include/errno.h" 2 3 4
+# 55 "/usr/include/errno.h" 3 4
+extern char *program_invocation_name, *program_invocation_short_name;
+
+
+
+}
+# 69 "/usr/include/errno.h" 3 4
+typedef int error_t;
+# 41 "/usr/include/python2.6/Python.h" 2
+# 56 "/usr/include/python2.6/Python.h"
+# 1 "/usr/include/assert.h" 1 3 4
+# 57 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/pyport.h" 1
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdint.h" 1 3 4
+
+
+# 1 "/usr/include/stdint.h" 1 3 4
+# 28 "/usr/include/stdint.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 29 "/usr/include/stdint.h" 2 3 4
+# 49 "/usr/include/stdint.h" 3 4
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+
+typedef unsigned int uint32_t;
+
+
+
+typedef unsigned long int uint64_t;
+# 66 "/usr/include/stdint.h" 3 4
+typedef signed char int_least8_t;
+typedef short int int_least16_t;
+typedef int int_least32_t;
+
+typedef long int int_least64_t;
+
+
+
+
+
+
+typedef unsigned char uint_least8_t;
+typedef unsigned short int uint_least16_t;
+typedef unsigned int uint_least32_t;
+
+typedef unsigned long int uint_least64_t;
+# 91 "/usr/include/stdint.h" 3 4
+typedef signed char int_fast8_t;
+
+typedef long int int_fast16_t;
+typedef long int int_fast32_t;
+typedef long int int_fast64_t;
+# 104 "/usr/include/stdint.h" 3 4
+typedef unsigned char uint_fast8_t;
+
+typedef unsigned long int uint_fast16_t;
+typedef unsigned long int uint_fast32_t;
+typedef unsigned long int uint_fast64_t;
+# 123 "/usr/include/stdint.h" 3 4
+typedef unsigned long int uintptr_t;
+# 135 "/usr/include/stdint.h" 3 4
+typedef long int intmax_t;
+typedef unsigned long int uintmax_t;
+# 4 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stdint.h" 2 3 4
+# 8 "/usr/include/python2.6/pyport.h" 2
+# 89 "/usr/include/python2.6/pyport.h"
+typedef uintptr_t Py_uintptr_t;
+typedef intptr_t Py_intptr_t;
+# 113 "/usr/include/python2.6/pyport.h"
+typedef ssize_t Py_ssize_t;
+# 235 "/usr/include/python2.6/pyport.h"
+# 1 "/usr/include/math.h" 1 3 4
+# 30 "/usr/include/math.h" 3 4
+extern "C" {
+
+
+
+# 1 "/usr/include/bits/huge_val.h" 1 3 4
+# 35 "/usr/include/math.h" 2 3 4
+
+# 1 "/usr/include/bits/huge_valf.h" 1 3 4
+# 37 "/usr/include/math.h" 2 3 4
+# 1 "/usr/include/bits/huge_vall.h" 1 3 4
+# 38 "/usr/include/math.h" 2 3 4
+
+
+# 1 "/usr/include/bits/inf.h" 1 3 4
+# 41 "/usr/include/math.h" 2 3 4
+
+
+# 1 "/usr/include/bits/nan.h" 1 3 4
+# 44 "/usr/include/math.h" 2 3 4
+
+
+
+# 1 "/usr/include/bits/mathdef.h" 1 3 4
+# 26 "/usr/include/bits/mathdef.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 27 "/usr/include/bits/mathdef.h" 2 3 4
+
+
+
+
+typedef float float_t;
+typedef double double_t;
+# 48 "/usr/include/math.h" 2 3 4
+# 71 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+
+
+extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
+
+extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
+
+extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
+
+extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
+
+
+extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
+
+extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
+
+extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
+
+
+
+
+extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
+
+extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
+
+extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
+
+
+
+
+extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ()
+                                                           ;
+
+
+
+
+
+extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
+
+extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
+
+extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
+
+
+
+
+
+
+
+extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
+
+
+extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
+
+
+extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
+
+
+extern double log (double __x) throw (); extern double __log (double __x) throw ();
+
+
+extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
+
+
+extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw ();
+
+
+
+
+extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
+
+extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
+
+
+
+
+
+extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
+
+
+extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
+
+
+extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
+
+
+
+
+
+
+extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
+
+
+extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
+
+
+
+
+
+
+
+
+extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
+
+
+extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
+
+
+
+
+
+extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
+
+
+
+
+
+
+extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
+
+
+
+
+
+
+
+
+extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
+
+
+extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
+
+
+extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
+
+
+extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
+
+
+
+
+extern int __isinf (double __value) throw () __attribute__ ((__const__));
+
+
+extern int __finite (double __value) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int isinf (double __value) throw () __attribute__ ((__const__));
+
+
+extern int finite (double __value) throw () __attribute__ ((__const__));
+
+
+extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
+
+
+
+extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
+
+
+
+
+
+extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int __isnan (double __value) throw () __attribute__ ((__const__));
+
+
+
+extern int isnan (double __value) throw () __attribute__ ((__const__));
+
+
+extern double j0 (double) throw (); extern double __j0 (double) throw ();
+extern double j1 (double) throw (); extern double __j1 (double) throw ();
+extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
+extern double y0 (double) throw (); extern double __y0 (double) throw ();
+extern double y1 (double) throw (); extern double __y1 (double) throw ();
+extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
+
+
+
+
+
+
+extern double erf (double) throw (); extern double __erf (double) throw ();
+extern double erfc (double) throw (); extern double __erfc (double) throw ();
+extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
+
+
+
+
+
+
+extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
+
+
+
+
+
+extern double gamma (double) throw (); extern double __gamma (double) throw ();
+
+
+
+
+
+
+extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
+
+
+
+
+
+
+
+extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
+
+
+extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
+
+extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
+
+
+
+extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
+
+
+
+extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
+
+
+
+
+extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
+
+
+
+extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
+
+
+
+extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
+
+
+
+extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
+extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
+
+
+
+extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
+extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
+
+
+
+extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
+
+
+extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw ();
+
+
+extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw ();
+
+
+
+extern int __fpclassify (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbit (double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
+
+
+
+
+
+
+
+
+extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
+# 72 "/usr/include/math.h" 2 3 4
+# 94 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+
+
+extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
+
+extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
+
+extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
+
+extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
+
+
+extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
+
+extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
+
+extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
+
+
+
+
+extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
+
+extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
+
+extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
+
+
+
+
+extern void
+ sincosf
+# 82 "/usr/include/bits/mathcalls.h" 3 4
+ (float __x, float *__sinx, float *__cosx) throw (); extern void
+ __sincosf
+# 82 "/usr/include/bits/mathcalls.h" 3 4
+ (float __x, float *__sinx, float *__cosx) throw ()
+                                                           ;
+
+
+
+
+
+extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
+
+extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
+
+extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
+
+
+
+
+
+
+
+extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
+
+
+extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
+
+
+extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
+
+
+extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
+
+
+extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
+
+
+extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw ();
+
+
+
+
+extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
+
+extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
+
+
+
+
+
+extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
+
+
+extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
+
+
+extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
+
+
+
+
+
+
+extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
+
+
+extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
+
+
+
+
+
+
+
+
+extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
+
+
+extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
+
+
+
+
+
+extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
+
+
+
+
+
+
+extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
+
+
+
+
+
+
+
+
+extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
+
+
+extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
+
+
+
+
+extern int __isinff (float __value) throw () __attribute__ ((__const__));
+
+
+extern int __finitef (float __value) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int isinff (float __value) throw () __attribute__ ((__const__));
+
+
+extern int finitef (float __value) throw () __attribute__ ((__const__));
+
+
+extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
+
+
+
+extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
+
+
+
+
+
+extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int __isnanf (float __value) throw () __attribute__ ((__const__));
+
+
+
+extern int isnanf (float __value) throw () __attribute__ ((__const__));
+
+
+extern float j0f (float) throw (); extern float __j0f (float) throw ();
+extern float j1f (float) throw (); extern float __j1f (float) throw ();
+extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
+extern float y0f (float) throw (); extern float __y0f (float) throw ();
+extern float y1f (float) throw (); extern float __y1f (float) throw ();
+extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
+
+
+
+
+
+
+extern float erff (float) throw (); extern float __erff (float) throw ();
+extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
+extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
+
+
+
+
+
+
+extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
+
+
+
+
+
+extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
+
+
+
+
+
+
+extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
+
+
+
+
+
+
+
+extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
+
+
+extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
+
+extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
+
+
+
+extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
+
+
+
+extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
+
+
+
+
+extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
+
+
+
+extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
+
+
+
+extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
+
+
+
+extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
+extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
+
+
+
+extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
+extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
+
+
+
+extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
+
+
+extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw ();
+
+
+extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw ();
+
+
+
+extern int __fpclassifyf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbitf (float __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
+
+
+
+
+
+
+
+
+extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
+# 95 "/usr/include/math.h" 2 3 4
+# 141 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathcalls.h" 1 3 4
+# 53 "/usr/include/bits/mathcalls.h" 3 4
+
+
+extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
+
+extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
+
+extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
+
+extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
+
+
+extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
+
+extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
+
+extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
+
+
+
+
+extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
+
+extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
+
+extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
+
+
+
+
+extern void
+ sincosl
+# 82 "/usr/include/bits/mathcalls.h" 3 4
+ (long double __x, long double *__sinx, long double *__cosx) throw (); extern void
+ __sincosl
+# 82 "/usr/include/bits/mathcalls.h" 3 4
+ (long double __x, long double *__sinx, long double *__cosx) throw ()
+                                                           ;
+
+
+
+
+
+extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
+
+extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
+
+extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
+
+
+
+
+
+
+
+extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
+
+
+extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
+
+
+extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
+
+
+extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
+
+
+extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
+
+
+extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw ();
+
+
+
+
+extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
+
+extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
+
+
+
+
+
+extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
+
+
+extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
+
+
+extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
+
+
+
+
+
+
+extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
+
+
+extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
+
+
+
+
+
+
+
+
+extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
+
+
+extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
+
+
+
+
+
+extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
+
+
+
+
+
+
+extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
+
+
+
+
+
+
+
+
+extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
+
+
+extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
+
+
+
+
+extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
+
+
+extern int __finitel (long double __value) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int isinfl (long double __value) throw () __attribute__ ((__const__));
+
+
+extern int finitel (long double __value) throw () __attribute__ ((__const__));
+
+
+extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
+
+
+
+extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
+
+
+
+
+
+extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+
+
+
+extern long double nanl (__const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (__const char *__tagb) throw () __attribute__ ((__const__));
+
+
+
+
+
+extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
+
+
+
+extern int isnanl (long double __value) throw () __attribute__ ((__const__));
+
+
+extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
+extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
+extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
+extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
+extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
+extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
+
+
+
+
+
+
+extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
+extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
+extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
+
+
+
+
+
+
+extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
+
+
+
+
+
+extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
+
+
+
+
+
+
+extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
+
+
+
+
+
+
+
+extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
+
+
+extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
+
+
+
+extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
+
+
+
+extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
+
+
+
+extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
+
+
+
+
+extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
+
+
+
+extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
+
+
+
+extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
+
+
+
+extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
+
+
+
+
+extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
+
+
+
+
+
+
+extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
+extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
+
+
+
+extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
+extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
+
+
+
+extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
+
+
+extern long double fmaxl (long double __x, long double __y) throw (); extern long double __fmaxl (long double __x, long double __y) throw ();
+
+
+extern long double fminl (long double __x, long double __y) throw (); extern long double __fminl (long double __x, long double __y) throw ();
+
+
+
+extern int __fpclassifyl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+extern int __signbitl (long double __value) throw ()
+     __attribute__ ((__const__));
+
+
+
+extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
+
+
+
+
+
+
+
+
+extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
+# 142 "/usr/include/math.h" 2 3 4
+# 157 "/usr/include/math.h" 3 4
+extern int signgam;
+# 198 "/usr/include/math.h" 3 4
+enum
+  {
+    FP_NAN,
+
+    FP_INFINITE,
+
+    FP_ZERO,
+
+    FP_SUBNORMAL,
+
+    FP_NORMAL
+
+  };
+# 291 "/usr/include/math.h" 3 4
+typedef enum
+{
+  _IEEE_ = -1,
+  _SVID_,
+  _XOPEN_,
+  _POSIX_,
+  _ISOC_
+} _LIB_VERSION_TYPE;
+
+
+
+
+extern _LIB_VERSION_TYPE _LIB_VERSION;
+# 314 "/usr/include/math.h" 3 4
+struct __exception
+
+
+
+  {
+    int type;
+    char *name;
+    double arg1;
+    double arg2;
+    double retval;
+  };
+
+
+extern int matherr (struct __exception *__exc) throw ();
+# 416 "/usr/include/math.h" 3 4
+# 1 "/usr/include/bits/mathinline.h" 1 3 4
+# 25 "/usr/include/bits/mathinline.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 26 "/usr/include/bits/mathinline.h" 2 3 4
+# 37 "/usr/include/bits/mathinline.h" 3 4
+extern __inline __attribute__ ((__gnu_inline__)) int
+__signbitf (float __x) throw ()
+{
+
+
+
+
+  int __m;
+  __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
+  return __m & 0x8;
+
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+__signbit (double __x) throw ()
+{
+
+
+
+
+  int __m;
+  __asm ("pmovmskb %1, %0" : "=r" (__m) : "x" (__x));
+  return __m & 0x80;
+
+}
+extern __inline __attribute__ ((__gnu_inline__)) int
+__signbitl (long double __x) throw ()
+{
+  __extension__ union { long double __l; int __i[3]; } __u = { __l: __x };
+  return (__u.__i[2] & 0x8000) != 0;
+}
+# 417 "/usr/include/math.h" 2 3 4
+# 472 "/usr/include/math.h" 3 4
+}
+# 236 "/usr/include/python2.6/pyport.h" 2
+
+
+
+
+
+
+# 1 "/usr/include/sys/time.h" 1 3 4
+# 29 "/usr/include/sys/time.h" 3 4
+# 1 "/usr/include/bits/time.h" 1 3 4
+# 30 "/usr/include/sys/time.h" 2 3 4
+# 39 "/usr/include/sys/time.h" 3 4
+extern "C" {
+# 57 "/usr/include/sys/time.h" 3 4
+struct timezone
+  {
+    int tz_minuteswest;
+    int tz_dsttime;
+  };
+
+typedef struct timezone *__restrict __timezone_ptr_t;
+# 73 "/usr/include/sys/time.h" 3 4
+extern int gettimeofday (struct timeval *__restrict __tv,
+    __timezone_ptr_t __tz) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int settimeofday (__const struct timeval *__tv,
+    __const struct timezone *__tz)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int adjtime (__const struct timeval *__delta,
+      struct timeval *__olddelta) throw ();
+
+
+
+
+enum __itimer_which
+  {
+
+    ITIMER_REAL = 0,
+
+
+    ITIMER_VIRTUAL = 1,
+
+
+
+    ITIMER_PROF = 2
+
+  };
+
+
+
+struct itimerval
+  {
+
+    struct timeval it_interval;
+
+    struct timeval it_value;
+  };
+
+
+
+
+
+
+typedef int __itimer_which_t;
+
+
+
+
+extern int getitimer (__itimer_which_t __which,
+        struct itimerval *__value) throw ();
+
+
+
+
+extern int setitimer (__itimer_which_t __which,
+        __const struct itimerval *__restrict __new,
+        struct itimerval *__restrict __old) throw ();
+
+
+
+
+extern int utimes (__const char *__file, __const struct timeval __tvp[2])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int lutimes (__const char *__file, __const struct timeval __tvp[2])
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int futimes (int __fd, __const struct timeval __tvp[2]) throw ();
+
+
+
+
+
+
+extern int futimesat (int __fd, __const char *__file,
+        __const struct timeval __tvp[2]) throw ();
+# 191 "/usr/include/sys/time.h" 3 4
+}
+# 243 "/usr/include/python2.6/pyport.h" 2
+# 300 "/usr/include/python2.6/pyport.h"
+# 1 "/usr/include/sys/stat.h" 1 3 4
+# 105 "/usr/include/sys/stat.h" 3 4
+extern "C" {
+
+# 1 "/usr/include/bits/stat.h" 1 3 4
+# 43 "/usr/include/bits/stat.h" 3 4
+struct stat
+  {
+    __dev_t st_dev;
+
+
+
+
+    __ino_t st_ino;
+
+
+
+
+
+
+
+    __nlink_t st_nlink;
+    __mode_t st_mode;
+
+    __uid_t st_uid;
+    __gid_t st_gid;
+
+    int __pad0;
+
+    __dev_t st_rdev;
+
+
+
+
+    __off_t st_size;
+
+
+
+    __blksize_t st_blksize;
+
+    __blkcnt_t st_blocks;
+# 88 "/usr/include/bits/stat.h" 3 4
+    struct timespec st_atim;
+    struct timespec st_mtim;
+    struct timespec st_ctim;
+# 103 "/usr/include/bits/stat.h" 3 4
+    long int __unused[3];
+# 112 "/usr/include/bits/stat.h" 3 4
+  };
+
+
+
+struct stat64
+  {
+    __dev_t st_dev;
+
+    __ino64_t st_ino;
+    __nlink_t st_nlink;
+    __mode_t st_mode;
+
+
+
+
+
+
+    __uid_t st_uid;
+    __gid_t st_gid;
+
+    int __pad0;
+    __dev_t st_rdev;
+    __off_t st_size;
+
+
+
+
+
+    __blksize_t st_blksize;
+    __blkcnt64_t st_blocks;
+
+
+
+
+
+
+
+    struct timespec st_atim;
+    struct timespec st_mtim;
+    struct timespec st_ctim;
+# 164 "/usr/include/bits/stat.h" 3 4
+    long int __unused[3];
+
+
+
+  };
+# 108 "/usr/include/sys/stat.h" 2 3 4
+# 209 "/usr/include/sys/stat.h" 3 4
+extern int stat (__const char *__restrict __file,
+   struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+extern int fstat (int __fd, struct stat *__buf) throw () __attribute__ ((__nonnull__ (2)));
+# 228 "/usr/include/sys/stat.h" 3 4
+extern int stat64 (__const char *__restrict __file,
+     struct stat64 *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
+extern int fstat64 (int __fd, struct stat64 *__buf) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+
+extern int fstatat (int __fd, __const char *__restrict __file,
+      struct stat *__restrict __buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+# 253 "/usr/include/sys/stat.h" 3 4
+extern int fstatat64 (int __fd, __const char *__restrict __file,
+        struct stat64 *__restrict __buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (2, 3)));
+
+
+
+
+
+
+
+extern int lstat (__const char *__restrict __file,
+    struct stat *__restrict __buf) throw () __attribute__ ((__nonnull__ (1, 2)));
+# 276 "/usr/include/sys/stat.h" 3 4
+extern int lstat64 (__const char *__restrict __file,
+      struct stat64 *__restrict __buf)
+     throw () __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+extern int chmod (__const char *__file, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int lchmod (__const char *__file, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+extern int fchmod (int __fd, __mode_t __mode) throw ();
+
+
+
+
+
+extern int fchmodat (int __fd, __const char *__file, __mode_t __mode,
+       int __flag)
+     throw () __attribute__ ((__nonnull__ (2))) __attribute__ ((__warn_unused_result__));
+
+
+
+
+
+
+extern __mode_t umask (__mode_t __mask) throw ();
+
+
+
+
+extern __mode_t getumask (void) throw ();
+
+
+
+extern int mkdir (__const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int mkdirat (int __fd, __const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+
+extern int mknod (__const char *__path, __mode_t __mode, __dev_t __dev)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int mknodat (int __fd, __const char *__path, __mode_t __mode,
+      __dev_t __dev) throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int mkfifo (__const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+extern int mkfifoat (int __fd, __const char *__path, __mode_t __mode)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+
+extern int utimensat (int __fd, __const char *__path,
+        __const struct timespec __times[2],
+        int __flags)
+     throw () __attribute__ ((__nonnull__ (2)));
+
+
+
+
+extern int futimens (int __fd, __const struct timespec __times[2]) throw ();
+# 399 "/usr/include/sys/stat.h" 3 4
+extern int __fxstat (int __ver, int __fildes, struct stat *__stat_buf)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int __xstat (int __ver, __const char *__filename,
+      struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __lxstat (int __ver, __const char *__filename,
+       struct stat *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __fxstatat (int __ver, int __fildes, __const char *__filename,
+         struct stat *__stat_buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (3, 4)));
+# 432 "/usr/include/sys/stat.h" 3 4
+extern int __fxstat64 (int __ver, int __fildes, struct stat64 *__stat_buf)
+     throw () __attribute__ ((__nonnull__ (3)));
+extern int __xstat64 (int __ver, __const char *__filename,
+        struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __lxstat64 (int __ver, __const char *__filename,
+         struct stat64 *__stat_buf) throw () __attribute__ ((__nonnull__ (2, 3)));
+extern int __fxstatat64 (int __ver, int __fildes, __const char *__filename,
+    struct stat64 *__stat_buf, int __flag)
+     throw () __attribute__ ((__nonnull__ (3, 4)));
+
+extern int __xmknod (int __ver, __const char *__path, __mode_t __mode,
+       __dev_t *__dev) throw () __attribute__ ((__nonnull__ (2, 4)));
+
+extern int __xmknodat (int __ver, int __fd, __const char *__path,
+         __mode_t __mode, __dev_t *__dev)
+     throw () __attribute__ ((__nonnull__ (3, 5)));
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+stat (__const char *__path, struct stat *__statbuf) throw ()
+{
+  return __xstat (1, __path, __statbuf);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+lstat (__const char *__path, struct stat *__statbuf) throw ()
+{
+  return __lxstat (1, __path, __statbuf);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+fstat (int __fd, struct stat *__statbuf) throw ()
+{
+  return __fxstat (1, __fd, __statbuf);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+fstatat (int __fd, __const char *__filename, struct stat *__statbuf, int __flag) throw ()
+
+{
+  return __fxstatat (1, __fd, __filename, __statbuf, __flag);
+}
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+mknod (__const char *__path, __mode_t __mode, __dev_t __dev) throw ()
+{
+  return __xmknod (0, __path, __mode, &__dev);
+}
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+mknodat (int __fd, __const char *__path, __mode_t __mode, __dev_t __dev) throw ()
+
+{
+  return __xmknodat (0, __fd, __path, __mode, &__dev);
+}
+
+
+
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+stat64 (__const char *__path, struct stat64 *__statbuf) throw ()
+{
+  return __xstat64 (1, __path, __statbuf);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+lstat64 (__const char *__path, struct stat64 *__statbuf) throw ()
+{
+  return __lxstat64 (1, __path, __statbuf);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+fstat64 (int __fd, struct stat64 *__statbuf) throw ()
+{
+  return __fxstat64 (1, __fd, __statbuf);
+}
+
+
+extern __inline __attribute__ ((__gnu_inline__)) int
+fstatat64 (int __fd, __const char *__filename, struct stat64 *__statbuf, int __flag) throw ()
+
+{
+  return __fxstatat64 (1, __fd, __filename, __statbuf, __flag);
+}
+
+
+
+
+
+
+}
+# 301 "/usr/include/python2.6/pyport.h" 2
+# 322 "/usr/include/python2.6/pyport.h"
+extern "C" {
+# 698 "/usr/include/python2.6/pyport.h"
+}
+# 59 "/usr/include/python2.6/Python.h" 2
+# 77 "/usr/include/python2.6/Python.h"
+# 1 "/usr/include/python2.6/pymath.h" 1
+# 78 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/pymem.h" 1
+# 11 "/usr/include/python2.6/pymem.h"
+extern "C" {
+# 52 "/usr/include/python2.6/pymem.h"
+void * PyMem_Malloc(size_t);
+void * PyMem_Realloc(void *, size_t);
+void PyMem_Free(void *);
+# 119 "/usr/include/python2.6/pymem.h"
+}
+# 79 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/object.h" 1
+
+
+
+extern "C" {
+# 106 "/usr/include/python2.6/object.h"
+typedef struct _object {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+} PyObject;
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
+} PyVarObject;
+# 133 "/usr/include/python2.6/object.h"
+typedef PyObject * (*unaryfunc)(PyObject *);
+typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
+typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
+typedef int (*inquiry)(PyObject *);
+typedef Py_ssize_t (*lenfunc)(PyObject *);
+typedef int (*coercion)(PyObject **, PyObject **);
+typedef PyObject *(*intargfunc)(PyObject *, int) __attribute__((__deprecated__));
+typedef PyObject *(*intintargfunc)(PyObject *, int, int) __attribute__((__deprecated__));
+typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
+typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
+typedef int(*intobjargproc)(PyObject *, int, PyObject *);
+typedef int(*intintobjargproc)(PyObject *, int, int, PyObject *);
+typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
+typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
+typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
+
+
+
+
+typedef int (*getreadbufferproc)(PyObject *, int, void **);
+typedef int (*getwritebufferproc)(PyObject *, int, void **);
+typedef int (*getsegcountproc)(PyObject *, int *);
+typedef int (*getcharbufferproc)(PyObject *, int, char **);
+
+typedef Py_ssize_t (*readbufferproc)(PyObject *, Py_ssize_t, void **);
+typedef Py_ssize_t (*writebufferproc)(PyObject *, Py_ssize_t, void **);
+typedef Py_ssize_t (*segcountproc)(PyObject *, Py_ssize_t *);
+typedef Py_ssize_t (*charbufferproc)(PyObject *, Py_ssize_t, char **);
+
+
+
+typedef struct bufferinfo {
+ void *buf;
+ PyObject *obj;
+        Py_ssize_t len;
+        Py_ssize_t itemsize;
+
+        int readonly;
+        int ndim;
+        char *format;
+        Py_ssize_t *shape;
+        Py_ssize_t *strides;
+        Py_ssize_t *suboffsets;
+        void *internal;
+} Py_buffer;
+
+typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
+typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
+# 213 "/usr/include/python2.6/object.h"
+typedef int (*objobjproc)(PyObject *, PyObject *);
+typedef int (*visitproc)(PyObject *, void *);
+typedef int (*traverseproc)(PyObject *, visitproc, void *);
+
+typedef struct {
+# 226 "/usr/include/python2.6/object.h"
+ binaryfunc nb_add;
+ binaryfunc nb_subtract;
+ binaryfunc nb_multiply;
+ binaryfunc nb_divide;
+ binaryfunc nb_remainder;
+ binaryfunc nb_divmod;
+ ternaryfunc nb_power;
+ unaryfunc nb_negative;
+ unaryfunc nb_positive;
+ unaryfunc nb_absolute;
+ inquiry nb_nonzero;
+ unaryfunc nb_invert;
+ binaryfunc nb_lshift;
+ binaryfunc nb_rshift;
+ binaryfunc nb_and;
+ binaryfunc nb_xor;
+ binaryfunc nb_or;
+ coercion nb_coerce;
+ unaryfunc nb_int;
+ unaryfunc nb_long;
+ unaryfunc nb_float;
+ unaryfunc nb_oct;
+ unaryfunc nb_hex;
+
+ binaryfunc nb_inplace_add;
+ binaryfunc nb_inplace_subtract;
+ binaryfunc nb_inplace_multiply;
+ binaryfunc nb_inplace_divide;
+ binaryfunc nb_inplace_remainder;
+ ternaryfunc nb_inplace_power;
+ binaryfunc nb_inplace_lshift;
+ binaryfunc nb_inplace_rshift;
+ binaryfunc nb_inplace_and;
+ binaryfunc nb_inplace_xor;
+ binaryfunc nb_inplace_or;
+
+
+
+ binaryfunc nb_floor_divide;
+ binaryfunc nb_true_divide;
+ binaryfunc nb_inplace_floor_divide;
+ binaryfunc nb_inplace_true_divide;
+
+
+ unaryfunc nb_index;
+} PyNumberMethods;
+
+typedef struct {
+ lenfunc sq_length;
+ binaryfunc sq_concat;
+ ssizeargfunc sq_repeat;
+ ssizeargfunc sq_item;
+ ssizessizeargfunc sq_slice;
+ ssizeobjargproc sq_ass_item;
+ ssizessizeobjargproc sq_ass_slice;
+ objobjproc sq_contains;
+
+ binaryfunc sq_inplace_concat;
+ ssizeargfunc sq_inplace_repeat;
+} PySequenceMethods;
+
+typedef struct {
+ lenfunc mp_length;
+ binaryfunc mp_subscript;
+ objobjargproc mp_ass_subscript;
+} PyMappingMethods;
+
+typedef struct {
+ readbufferproc bf_getreadbuffer;
+ writebufferproc bf_getwritebuffer;
+ segcountproc bf_getsegcount;
+ charbufferproc bf_getcharbuffer;
+        getbufferproc bf_getbuffer;
+ releasebufferproc bf_releasebuffer;
+} PyBufferProcs;
+
+
+typedef void (*freefunc)(void *);
+typedef void (*destructor)(PyObject *);
+typedef int (*printfunc)(PyObject *, FILE *, int);
+typedef PyObject *(*getattrfunc)(PyObject *, char *);
+typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
+typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
+typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
+typedef int (*cmpfunc)(PyObject *, PyObject *);
+typedef PyObject *(*reprfunc)(PyObject *);
+typedef long (*hashfunc)(PyObject *);
+typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
+typedef PyObject *(*getiterfunc) (PyObject *);
+typedef PyObject *(*iternextfunc) (PyObject *);
+typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
+typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
+typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
+typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
+typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);
+
+typedef struct _typeobject {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
+ const char *tp_name;
+ Py_ssize_t tp_basicsize, tp_itemsize;
+
+
+
+ destructor tp_dealloc;
+ printfunc tp_print;
+ getattrfunc tp_getattr;
+ setattrfunc tp_setattr;
+ cmpfunc tp_compare;
+ reprfunc tp_repr;
+
+
+
+ PyNumberMethods *tp_as_number;
+ PySequenceMethods *tp_as_sequence;
+ PyMappingMethods *tp_as_mapping;
+
+
+
+ hashfunc tp_hash;
+ ternaryfunc tp_call;
+ reprfunc tp_str;
+ getattrofunc tp_getattro;
+ setattrofunc tp_setattro;
+
+
+ PyBufferProcs *tp_as_buffer;
+
+
+ long tp_flags;
+
+ const char *tp_doc;
+
+
+
+ traverseproc tp_traverse;
+
+
+ inquiry tp_clear;
+
+
+
+ richcmpfunc tp_richcompare;
+
+
+ Py_ssize_t tp_weaklistoffset;
+
+
+
+ getiterfunc tp_iter;
+ iternextfunc tp_iternext;
+
+
+ struct PyMethodDef *tp_methods;
+ struct PyMemberDef *tp_members;
+ struct PyGetSetDef *tp_getset;
+ struct _typeobject *tp_base;
+ PyObject *tp_dict;
+ descrgetfunc tp_descr_get;
+ descrsetfunc tp_descr_set;
+ Py_ssize_t tp_dictoffset;
+ initproc tp_init;
+ allocfunc tp_alloc;
+ newfunc tp_new;
+ freefunc tp_free;
+ inquiry tp_is_gc;
+ PyObject *tp_bases;
+ PyObject *tp_mro;
+ PyObject *tp_cache;
+ PyObject *tp_subclasses;
+ PyObject *tp_weaklist;
+ destructor tp_del;
+
+
+ unsigned int tp_version_tag;
+# 409 "/usr/include/python2.6/object.h"
+} PyTypeObject;
+
+
+
+typedef struct _heaptypeobject {
+
+
+ PyTypeObject ht_type;
+ PyNumberMethods as_number;
+ PyMappingMethods as_mapping;
+ PySequenceMethods as_sequence;
+
+
+
+
+ PyBufferProcs as_buffer;
+ PyObject *ht_name, *ht_slots;
+
+} PyHeapTypeObject;
+
+
+
+
+
+
+
+int PyType_IsSubtype(PyTypeObject *, PyTypeObject *);
+
+
+
+extern PyTypeObject PyType_Type;
+extern PyTypeObject PyBaseObject_Type;
+extern PyTypeObject PySuper_Type;
+
+
+
+
+
+int PyType_Ready(PyTypeObject *);
+PyObject * PyType_GenericAlloc(PyTypeObject *, Py_ssize_t);
+PyObject * PyType_GenericNew(PyTypeObject *,
+            PyObject *, PyObject *);
+PyObject * _PyType_Lookup(PyTypeObject *, PyObject *);
+unsigned int PyType_ClearCache(void);
+void PyType_Modified(PyTypeObject *);
+
+
+int PyObject_Print(PyObject *, FILE *, int);
+void _PyObject_Dump(PyObject *);
+PyObject * PyObject_Repr(PyObject *);
+PyObject * _PyObject_Str(PyObject *);
+PyObject * PyObject_Str(PyObject *);
+
+
+PyObject * PyObject_Unicode(PyObject *);
+
+int PyObject_Compare(PyObject *, PyObject *);
+PyObject * PyObject_RichCompare(PyObject *, PyObject *, int);
+int PyObject_RichCompareBool(PyObject *, PyObject *, int);
+PyObject * PyObject_GetAttrString(PyObject *, const char *);
+int PyObject_SetAttrString(PyObject *, const char *, PyObject *);
+int PyObject_HasAttrString(PyObject *, const char *);
+PyObject * PyObject_GetAttr(PyObject *, PyObject *);
+int PyObject_SetAttr(PyObject *, PyObject *, PyObject *);
+int PyObject_HasAttr(PyObject *, PyObject *);
+PyObject ** _PyObject_GetDictPtr(PyObject *);
+PyObject * PyObject_SelfIter(PyObject *);
+PyObject * PyObject_GenericGetAttr(PyObject *, PyObject *);
+int PyObject_GenericSetAttr(PyObject *,
+           PyObject *, PyObject *);
+long PyObject_Hash(PyObject *);
+long PyObject_HashNotImplemented(PyObject *);
+int PyObject_IsTrue(PyObject *);
+int PyObject_Not(PyObject *);
+int PyCallable_Check(PyObject *);
+int PyNumber_Coerce(PyObject **, PyObject **);
+int PyNumber_CoerceEx(PyObject **, PyObject **);
+
+void PyObject_ClearWeakRefs(PyObject *);
+
+
+extern int _PyObject_SlotCompare(PyObject *, PyObject *);
+
+
+
+
+
+
+
+PyObject * PyObject_Dir(PyObject *);
+
+
+
+int Py_ReprEnter(PyObject *);
+void Py_ReprLeave(PyObject *);
+
+
+long _Py_HashDouble(double);
+long _Py_HashPointer(void*);
+# 806 "/usr/include/python2.6/object.h"
+void Py_IncRef(PyObject *);
+void Py_DecRef(PyObject *);
+
+
+
+
+
+
+
+extern PyObject _Py_NoneStruct;
+# 825 "/usr/include/python2.6/object.h"
+extern PyObject _Py_NotImplementedStruct;
+# 839 "/usr/include/python2.6/object.h"
+extern int _Py_SwappedOp[];
+# 951 "/usr/include/python2.6/object.h"
+void _PyTrash_deposit_object(PyObject*);
+void _PyTrash_destroy_chain(void);
+extern int _PyTrash_delete_nesting;
+extern PyObject * _PyTrash_delete_later;
+# 971 "/usr/include/python2.6/object.h"
+}
+# 81 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/objimpl.h" 1
+# 11 "/usr/include/python2.6/objimpl.h"
+extern "C" {
+# 97 "/usr/include/python2.6/objimpl.h"
+void * PyObject_Malloc(size_t);
+void * PyObject_Realloc(void *, size_t);
+void PyObject_Free(void *);
+# 143 "/usr/include/python2.6/objimpl.h"
+PyObject * PyObject_Init(PyObject *, PyTypeObject *);
+PyVarObject * PyObject_InitVar(PyVarObject *,
+                                                 PyTypeObject *, Py_ssize_t);
+PyObject * _PyObject_New(PyTypeObject *);
+PyVarObject * _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
+# 228 "/usr/include/python2.6/objimpl.h"
+Py_ssize_t PyGC_Collect(void);
+# 237 "/usr/include/python2.6/objimpl.h"
+PyVarObject * _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);
+
+
+
+
+
+
+
+typedef union _gc_head {
+ struct {
+  union _gc_head *gc_next;
+  union _gc_head *gc_prev;
+  Py_ssize_t gc_refs;
+ } gc;
+ long double dummy;
+} PyGC_Head;
+
+extern PyGC_Head *_PyGC_generation0;
+# 288 "/usr/include/python2.6/objimpl.h"
+PyObject * _PyObject_GC_Malloc(size_t);
+PyObject * _PyObject_GC_New(PyTypeObject *);
+PyVarObject * _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);
+void PyObject_GC_Track(void *);
+void PyObject_GC_UnTrack(void *);
+void PyObject_GC_Del(void *);
+# 334 "/usr/include/python2.6/objimpl.h"
+}
+# 82 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/pydebug.h" 1
+
+
+
+
+extern "C" {
+
+
+extern int Py_DebugFlag;
+extern int Py_VerboseFlag;
+extern int Py_InteractiveFlag;
+extern int Py_InspectFlag;
+extern int Py_OptimizeFlag;
+extern int Py_NoSiteFlag;
+extern int Py_BytesWarningFlag;
+extern int Py_UseClassExceptionsFlag;
+extern int Py_FrozenFlag;
+extern int Py_TabcheckFlag;
+extern int Py_UnicodeFlag;
+extern int Py_IgnoreEnvironmentFlag;
+extern int Py_DivisionWarningFlag;
+extern int Py_DontWriteBytecodeFlag;
+extern int Py_NoUserSiteDirectory;
+
+
+
+extern int _Py_QnewFlag;
+
+extern int Py_Py3kWarningFlag;
+
+
+
+
+
+
+void Py_FatalError(const char *message);
+
+
+}
+# 84 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/unicodeobject.h" 1
+# 120 "/usr/include/python2.6/unicodeobject.h"
+# 1 "/usr/include/wchar.h" 1 3 4
+# 121 "/usr/include/python2.6/unicodeobject.h" 2
+
+
+
+
+
+
+
+typedef unsigned int Py_UCS4;
+# 137 "/usr/include/python2.6/unicodeobject.h"
+typedef Py_UCS4 Py_UNICODE;
+# 410 "/usr/include/python2.6/unicodeobject.h"
+extern "C" {
+
+
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    Py_ssize_t length;
+    Py_UNICODE *str;
+    long hash;
+    PyObject *defenc;
+
+
+} PyUnicodeObject;
+
+extern PyTypeObject PyUnicode_Type;
+# 464 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_FromUnicode(
+    const Py_UNICODE *u,
+    Py_ssize_t size
+    );
+
+
+PyObject* PyUnicodeUCS4_FromStringAndSize(
+    const char *u,
+    Py_ssize_t size
+    );
+
+
+
+PyObject* PyUnicodeUCS4_FromString(
+    const char *u
+    );
+
+
+
+
+Py_UNICODE * PyUnicodeUCS4_AsUnicode(
+    PyObject *unicode
+    );
+
+
+
+Py_ssize_t PyUnicodeUCS4_GetSize(
+    PyObject *unicode
+    );
+
+
+Py_UNICODE PyUnicodeUCS4_GetMax(void);
+# 511 "/usr/include/python2.6/unicodeobject.h"
+int PyUnicodeUCS4_Resize(
+    PyObject **unicode,
+    Py_ssize_t length
+    );
+# 533 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_FromEncodedObject(
+    register PyObject *obj,
+    const char *encoding,
+    const char *errors
+    );
+# 552 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_FromObject(
+    register PyObject *obj
+    );
+
+PyObject * PyUnicodeUCS4_FromFormatV(const char*, va_list);
+PyObject * PyUnicodeUCS4_FromFormat(const char*, ...);
+
+
+
+PyObject * _PyUnicode_FormatAdvanced(PyObject *obj,
+       Py_UNICODE *format_spec,
+       Py_ssize_t format_spec_len);
+# 574 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_FromWideChar(
+    register const wchar_t *w,
+    Py_ssize_t size
+    );
+# 591 "/usr/include/python2.6/unicodeobject.h"
+Py_ssize_t PyUnicodeUCS4_AsWideChar(
+    PyUnicodeObject *unicode,
+    register wchar_t *w,
+    Py_ssize_t size
+    );
+# 609 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_FromOrdinal(int ordinal);
+# 620 "/usr/include/python2.6/unicodeobject.h"
+int PyUnicodeUCS4_ClearFreelist(void);
+# 656 "/usr/include/python2.6/unicodeobject.h"
+PyObject * _PyUnicodeUCS4_AsDefaultEncodedString(
+    PyObject *, const char *);
+# 668 "/usr/include/python2.6/unicodeobject.h"
+const char* PyUnicodeUCS4_GetDefaultEncoding(void);
+
+
+
+
+
+
+
+int PyUnicodeUCS4_SetDefaultEncoding(
+    const char *encoding
+    );
+
+
+
+
+
+
+PyObject* PyUnicodeUCS4_Decode(
+    const char *s,
+    Py_ssize_t size,
+    const char *encoding,
+    const char *errors
+    );
+
+
+
+
+PyObject* PyUnicodeUCS4_Encode(
+    const Py_UNICODE *s,
+    Py_ssize_t size,
+    const char *encoding,
+    const char *errors
+    );
+
+
+
+
+PyObject* PyUnicodeUCS4_AsEncodedObject(
+    PyObject *unicode,
+    const char *encoding,
+    const char *errors
+    );
+
+
+
+
+PyObject* PyUnicodeUCS4_AsEncodedString(
+    PyObject *unicode,
+    const char *encoding,
+    const char *errors
+    );
+
+PyObject* PyUnicode_BuildEncodingMap(
+    PyObject* string
+   );
+
+
+
+
+PyObject* PyUnicode_DecodeUTF7(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+PyObject* PyUnicode_DecodeUTF7Stateful(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors,
+    Py_ssize_t *consumed
+    );
+
+PyObject* PyUnicode_EncodeUTF7(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    int encodeSetO,
+
+    int encodeWhiteSpace,
+
+    const char *errors
+    );
+
+
+
+PyObject* PyUnicodeUCS4_DecodeUTF8(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+PyObject* PyUnicodeUCS4_DecodeUTF8Stateful(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors,
+    Py_ssize_t *consumed
+    );
+
+PyObject* PyUnicodeUCS4_AsUTF8String(
+    PyObject *unicode
+    );
+
+PyObject* PyUnicodeUCS4_EncodeUTF8(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    const char *errors
+    );
+# 800 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_DecodeUTF32(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors,
+    int *byteorder
+
+
+    );
+
+PyObject* PyUnicodeUCS4_DecodeUTF32Stateful(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors,
+    int *byteorder,
+
+
+    Py_ssize_t *consumed
+    );
+
+
+
+
+PyObject* PyUnicodeUCS4_AsUTF32String(
+    PyObject *unicode
+    );
+# 842 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_EncodeUTF32(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    const char *errors,
+    int byteorder
+    );
+# 874 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_DecodeUTF16(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors,
+    int *byteorder
+
+
+    );
+
+PyObject* PyUnicodeUCS4_DecodeUTF16Stateful(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors,
+    int *byteorder,
+
+
+    Py_ssize_t *consumed
+    );
+
+
+
+
+PyObject* PyUnicodeUCS4_AsUTF16String(
+    PyObject *unicode
+    );
+# 920 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_EncodeUTF16(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    const char *errors,
+    int byteorder
+    );
+
+
+
+PyObject* PyUnicodeUCS4_DecodeUnicodeEscape(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+PyObject* PyUnicodeUCS4_AsUnicodeEscapeString(
+    PyObject *unicode
+    );
+
+PyObject* PyUnicodeUCS4_EncodeUnicodeEscape(
+    const Py_UNICODE *data,
+    Py_ssize_t length
+    );
+
+
+
+PyObject* PyUnicodeUCS4_DecodeRawUnicodeEscape(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+PyObject* PyUnicodeUCS4_AsRawUnicodeEscapeString(
+    PyObject *unicode
+    );
+
+PyObject* PyUnicodeUCS4_EncodeRawUnicodeEscape(
+    const Py_UNICODE *data,
+    Py_ssize_t length
+    );
+
+
+
+
+
+PyObject *_PyUnicode_DecodeUnicodeInternal(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+
+
+
+
+
+
+PyObject* PyUnicodeUCS4_DecodeLatin1(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+PyObject* PyUnicodeUCS4_AsLatin1String(
+    PyObject *unicode
+    );
+
+PyObject* PyUnicodeUCS4_EncodeLatin1(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+
+
+
+
+
+
+PyObject* PyUnicodeUCS4_DecodeASCII(
+    const char *string,
+    Py_ssize_t length,
+    const char *errors
+    );
+
+PyObject* PyUnicodeUCS4_AsASCIIString(
+    PyObject *unicode
+    );
+
+PyObject* PyUnicodeUCS4_EncodeASCII(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    const char *errors
+    );
+# 1037 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_DecodeCharmap(
+    const char *string,
+    Py_ssize_t length,
+    PyObject *mapping,
+
+    const char *errors
+    );
+
+PyObject* PyUnicodeUCS4_AsCharmapString(
+    PyObject *unicode,
+    PyObject *mapping
+
+    );
+
+PyObject* PyUnicodeUCS4_EncodeCharmap(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    PyObject *mapping,
+
+    const char *errors
+    );
+# 1072 "/usr/include/python2.6/unicodeobject.h"
+PyObject * PyUnicodeUCS4_TranslateCharmap(
+    const Py_UNICODE *data,
+    Py_ssize_t length,
+    PyObject *table,
+    const char *errors
+    );
+# 1132 "/usr/include/python2.6/unicodeobject.h"
+int PyUnicodeUCS4_EncodeDecimal(
+    Py_UNICODE *s,
+    Py_ssize_t length,
+    char *output,
+    const char *errors
+    );
+# 1147 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_Concat(
+    PyObject *left,
+    PyObject *right
+    );
+# 1163 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_Split(
+    PyObject *s,
+    PyObject *sep,
+    Py_ssize_t maxsplit
+    );
+
+
+
+
+
+
+PyObject* PyUnicodeUCS4_Splitlines(
+    PyObject *s,
+    int keepends
+    );
+
+
+
+PyObject* PyUnicodeUCS4_Partition(
+    PyObject *s,
+    PyObject *sep
+    );
+
+
+
+
+PyObject* PyUnicodeUCS4_RPartition(
+    PyObject *s,
+    PyObject *sep
+    );
+# 1207 "/usr/include/python2.6/unicodeobject.h"
+PyObject* PyUnicodeUCS4_RSplit(
+    PyObject *s,
+    PyObject *sep,
+    Py_ssize_t maxsplit
+    );
+# 1225 "/usr/include/python2.6/unicodeobject.h"
+PyObject * PyUnicodeUCS4_Translate(
+    PyObject *str,
+    PyObject *table,
+    const char *errors
+    );
+
+
+
+
+PyObject* PyUnicodeUCS4_Join(
+    PyObject *separator,
+    PyObject *seq
+    );
+
+
+
+
+Py_ssize_t PyUnicodeUCS4_Tailmatch(
+    PyObject *str,
+    PyObject *substr,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    int direction
+    );
+
+
+
+
+
+Py_ssize_t PyUnicodeUCS4_Find(
+    PyObject *str,
+    PyObject *substr,
+    Py_ssize_t start,
+    Py_ssize_t end,
+    int direction
+    );
+
+
+
+Py_ssize_t PyUnicodeUCS4_Count(
+    PyObject *str,
+    PyObject *substr,
+    Py_ssize_t start,
+    Py_ssize_t end
+    );
+
+
+
+
+PyObject * PyUnicodeUCS4_Replace(
+    PyObject *str,
+    PyObject *substr,
+    PyObject *replstr,
+    Py_ssize_t maxcount
+
+    );
+
+
+
+
+int PyUnicodeUCS4_Compare(
+    PyObject *left,
+    PyObject *right
+    );
+# 1306 "/usr/include/python2.6/unicodeobject.h"
+PyObject * PyUnicodeUCS4_RichCompare(
+    PyObject *left,
+    PyObject *right,
+    int op
+    );
+
+
+
+
+PyObject * PyUnicodeUCS4_Format(
+    PyObject *format,
+    PyObject *args
+    );
+
+
+
+
+
+
+
+int PyUnicodeUCS4_Contains(
+    PyObject *container,
+    PyObject *element
+    );
+
+
+PyObject * _PyUnicode_XStrip(
+    PyUnicodeObject *self,
+    int striptype,
+    PyObject *sepobj
+    );
+
+
+
+
+
+extern const unsigned char _Py_ascii_whitespace[];
+# 1351 "/usr/include/python2.6/unicodeobject.h"
+int _PyUnicodeUCS4_IsLowercase(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsUppercase(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsTitlecase(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsWhitespace(
+    const Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsLinebreak(
+    const Py_UNICODE ch
+    );
+
+Py_UNICODE _PyUnicodeUCS4_ToLowercase(
+    Py_UNICODE ch
+    );
+
+Py_UNICODE _PyUnicodeUCS4_ToUppercase(
+    Py_UNICODE ch
+    );
+
+Py_UNICODE _PyUnicodeUCS4_ToTitlecase(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_ToDecimalDigit(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_ToDigit(
+    Py_UNICODE ch
+    );
+
+double _PyUnicodeUCS4_ToNumeric(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsDecimalDigit(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsDigit(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsNumeric(
+    Py_UNICODE ch
+    );
+
+int _PyUnicodeUCS4_IsAlpha(
+    Py_UNICODE ch
+    );
+
+
+}
+# 86 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/intobject.h" 1
+# 20 "/usr/include/python2.6/intobject.h"
+extern "C" {
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    long ob_ival;
+} PyIntObject;
+
+extern PyTypeObject PyInt_Type;
+
+
+
+
+
+PyObject * PyInt_FromString(char*, char**, int);
+
+PyObject * PyInt_FromUnicode(Py_UNICODE*, Py_ssize_t, int);
+
+PyObject * PyInt_FromLong(long);
+PyObject * PyInt_FromSize_t(size_t);
+PyObject * PyInt_FromSsize_t(Py_ssize_t);
+long PyInt_AsLong(PyObject *);
+Py_ssize_t PyInt_AsSsize_t(PyObject *);
+unsigned long PyInt_AsUnsignedLongMask(PyObject *);
+
+unsigned long long PyInt_AsUnsignedLongLongMask(PyObject *);
+
+
+long PyInt_GetMax(void);
+# 59 "/usr/include/python2.6/intobject.h"
+unsigned long PyOS_strtoul(char *, char **, int);
+long PyOS_strtol(char *, char **, int);
+
+
+int PyInt_ClearFreeList(void);
+
+
+
+
+
+PyObject* _PyInt_Format(PyIntObject* v, int base, int newstyle);
+
+
+
+PyObject * _PyInt_FormatAdvanced(PyObject *obj,
+          char *format_spec,
+          Py_ssize_t format_spec_len);
+
+
+}
+# 87 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/boolobject.h" 1
+
+
+
+
+
+extern "C" {
+
+
+
+typedef PyIntObject PyBoolObject;
+
+extern PyTypeObject PyBool_Type;
+
+
+
+
+
+
+
+extern PyIntObject _Py_ZeroStruct, _Py_TrueStruct;
+# 31 "/usr/include/python2.6/boolobject.h"
+PyObject * PyBool_FromLong(long);
+
+
+}
+# 88 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/longobject.h" 1
+
+
+
+extern "C" {
+
+
+
+
+
+typedef struct _longobject PyLongObject;
+
+extern PyTypeObject PyLong_Type;
+
+
+
+
+
+PyObject * PyLong_FromLong(long);
+PyObject * PyLong_FromUnsignedLong(unsigned long);
+PyObject * PyLong_FromDouble(double);
+PyObject * PyLong_FromSize_t(size_t);
+PyObject * PyLong_FromSsize_t(Py_ssize_t);
+long PyLong_AsLong(PyObject *);
+unsigned long PyLong_AsUnsignedLong(PyObject *);
+unsigned long PyLong_AsUnsignedLongMask(PyObject *);
+Py_ssize_t PyLong_AsSsize_t(PyObject *);
+
+
+
+
+
+extern int _PyLong_DigitValue[256];
+
+
+
+
+
+
+
+double _PyLong_AsScaledDouble(PyObject *vv, int *e);
+
+double PyLong_AsDouble(PyObject *);
+PyObject * PyLong_FromVoidPtr(void *);
+void * PyLong_AsVoidPtr(PyObject *);
+
+
+PyObject * PyLong_FromLongLong(long long);
+PyObject * PyLong_FromUnsignedLongLong(unsigned long long);
+long long PyLong_AsLongLong(PyObject *);
+unsigned long long PyLong_AsUnsignedLongLong(PyObject *);
+unsigned long long PyLong_AsUnsignedLongLongMask(PyObject *);
+
+
+PyObject * PyLong_FromString(char *, char **, int);
+
+PyObject * PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int);
+
+
+
+
+
+
+int _PyLong_Sign(PyObject *v);
+# 73 "/usr/include/python2.6/longobject.h"
+size_t _PyLong_NumBits(PyObject *v);
+# 88 "/usr/include/python2.6/longobject.h"
+PyObject * _PyLong_FromByteArray(
+ const unsigned char* bytes, size_t n,
+ int little_endian, int is_signed);
+# 111 "/usr/include/python2.6/longobject.h"
+int _PyLong_AsByteArray(PyLongObject* v,
+ unsigned char* bytes, size_t n,
+ int little_endian, int is_signed);
+
+
+
+
+
+
+PyObject * _PyLong_Format(PyObject *aa, int base, int addL, int newstyle);
+
+
+
+PyObject * _PyLong_FormatAdvanced(PyObject *obj,
+           char *format_spec,
+           Py_ssize_t format_spec_len);
+
+
+}
+# 89 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/floatobject.h" 1
+# 11 "/usr/include/python2.6/floatobject.h"
+extern "C" {
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    double ob_fval;
+} PyFloatObject;
+
+extern PyTypeObject PyFloat_Type;
+# 35 "/usr/include/python2.6/floatobject.h"
+double PyFloat_GetMax(void);
+double PyFloat_GetMin(void);
+PyObject * PyFloat_GetInfo(void);
+
+
+
+
+PyObject * PyFloat_FromString(PyObject*, char** junk);
+
+
+PyObject * PyFloat_FromDouble(double);
+
+
+
+double PyFloat_AsDouble(PyObject *);
+
+
+
+
+
+
+void PyFloat_AsReprString(char*, PyFloatObject *v);
+
+
+
+
+
+
+void PyFloat_AsString(char*, PyFloatObject *v);
+# 97 "/usr/include/python2.6/floatobject.h"
+int _PyFloat_Pack4(double x, unsigned char *p, int le);
+int _PyFloat_Pack8(double x, unsigned char *p, int le);
+
+
+int _PyFloat_Digits(char *buf, double v, int *signum);
+void _PyFloat_DigitsInit(void);
+# 112 "/usr/include/python2.6/floatobject.h"
+double _PyFloat_Unpack4(const unsigned char *p, int le);
+double _PyFloat_Unpack8(const unsigned char *p, int le);
+
+
+int PyFloat_ClearFreeList(void);
+
+
+
+PyObject * _PyFloat_FormatAdvanced(PyObject *obj,
+            char *format_spec,
+            Py_ssize_t format_spec_len);
+
+
+}
+# 90 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/complexobject.h" 1
+
+
+
+
+
+extern "C" {
+
+
+typedef struct {
+    double real;
+    double imag;
+} Py_complex;
+# 24 "/usr/include/python2.6/complexobject.h"
+Py_complex _Py_c_sum(Py_complex, Py_complex);
+Py_complex _Py_c_diff(Py_complex, Py_complex);
+Py_complex _Py_c_neg(Py_complex);
+Py_complex _Py_c_prod(Py_complex, Py_complex);
+Py_complex _Py_c_quot(Py_complex, Py_complex);
+Py_complex _Py_c_pow(Py_complex, Py_complex);
+double _Py_c_abs(Py_complex);
+# 40 "/usr/include/python2.6/complexobject.h"
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    Py_complex cval;
+} PyComplexObject;
+
+extern PyTypeObject PyComplex_Type;
+
+
+
+
+PyObject * PyComplex_FromCComplex(Py_complex);
+PyObject * PyComplex_FromDoubles(double real, double imag);
+
+double PyComplex_RealAsDouble(PyObject *op);
+double PyComplex_ImagAsDouble(PyObject *op);
+Py_complex PyComplex_AsCComplex(PyObject *op);
+
+
+}
+# 92 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/rangeobject.h" 1
+
+
+
+
+
+
+extern "C" {
+# 21 "/usr/include/python2.6/rangeobject.h"
+extern PyTypeObject PyRange_Type;
+
+
+
+
+}
+# 94 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/stringobject.h" 1
+
+
+
+
+
+
+extern "C" {
+# 35 "/usr/include/python2.6/stringobject.h"
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
+    long ob_shash;
+    int ob_sstate;
+    char ob_sval[1];
+# 49 "/usr/include/python2.6/stringobject.h"
+} PyStringObject;
+
+
+
+
+
+extern PyTypeObject PyBaseString_Type;
+extern PyTypeObject PyString_Type;
+
+
+
+
+
+PyObject * PyString_FromStringAndSize(const char *, Py_ssize_t);
+PyObject * PyString_FromString(const char *);
+PyObject * PyString_FromFormatV(const char*, va_list)
+    __attribute__((format(printf, 1, 0)));
+PyObject * PyString_FromFormat(const char*, ...)
+    __attribute__((format(printf, 1, 2)));
+Py_ssize_t PyString_Size(PyObject *);
+char * PyString_AsString(PyObject *);
+PyObject * PyString_Repr(PyObject *, int);
+void PyString_Concat(PyObject **, PyObject *);
+void PyString_ConcatAndDel(PyObject **, PyObject *);
+int _PyString_Resize(PyObject **, Py_ssize_t);
+int _PyString_Eq(PyObject *, PyObject*);
+PyObject * PyString_Format(PyObject *, PyObject *);
+PyObject * _PyString_FormatLong(PyObject*, int, int,
+        int, char**, int*);
+PyObject * PyString_DecodeEscape(const char *, Py_ssize_t,
+         const char *, Py_ssize_t,
+         const char *);
+
+void PyString_InternInPlace(PyObject **);
+void PyString_InternImmortal(PyObject **);
+PyObject * PyString_InternFromString(const char *);
+void _Py_ReleaseInternedStrings(void);
+# 96 "/usr/include/python2.6/stringobject.h"
+PyObject * _PyString_Join(PyObject *sep, PyObject *x);
+
+
+
+
+
+
+PyObject* PyString_Decode(
+    const char *s,
+    Py_ssize_t size,
+    const char *encoding,
+    const char *errors
+    );
+
+
+
+
+PyObject* PyString_Encode(
+    const char *s,
+    Py_ssize_t size,
+    const char *encoding,
+    const char *errors
+    );
+
+
+
+
+PyObject* PyString_AsEncodedObject(
+    PyObject *str,
+    const char *encoding,
+    const char *errors
+    );
+# 137 "/usr/include/python2.6/stringobject.h"
+PyObject* PyString_AsEncodedString(
+    PyObject *str,
+    const char *encoding,
+    const char *errors
+    );
+
+
+
+
+PyObject* PyString_AsDecodedObject(
+    PyObject *str,
+    const char *encoding,
+    const char *errors
+    );
+# 160 "/usr/include/python2.6/stringobject.h"
+PyObject* PyString_AsDecodedString(
+    PyObject *str,
+    const char *encoding,
+    const char *errors
+    );
+
+
+
+
+
+
+
+int PyString_AsStringAndSize(
+    register PyObject *obj,
+    register char **s,
+    register Py_ssize_t *len
+
+
+    );
+
+
+
+
+
+int _PyString_InsertThousandsGrouping(char *buffer,
+        Py_ssize_t n_buffer,
+        Py_ssize_t n_digits,
+        Py_ssize_t buf_size,
+        Py_ssize_t *count,
+        int append_zero_char);
+
+
+
+PyObject * _PyBytes_FormatAdvanced(PyObject *obj,
+            char *format_spec,
+            Py_ssize_t format_spec_len);
+
+
+}
+# 95 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/bufferobject.h" 1
+# 9 "/usr/include/python2.6/bufferobject.h"
+extern "C" {
+
+
+
+extern PyTypeObject PyBuffer_Type;
+
+
+
+
+
+PyObject * PyBuffer_FromObject(PyObject *base,
+                                           Py_ssize_t offset, Py_ssize_t size);
+PyObject * PyBuffer_FromReadWriteObject(PyObject *base,
+                                                    Py_ssize_t offset,
+                                                    Py_ssize_t size);
+
+PyObject * PyBuffer_FromMemory(void *ptr, Py_ssize_t size);
+PyObject * PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size);
+
+PyObject * PyBuffer_New(Py_ssize_t size);
+
+
+}
+# 97 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/bytesobject.h" 1
+# 98 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/bytearrayobject.h" 1
+
+
+
+
+
+extern "C" {
+# 22 "/usr/include/python2.6/bytearrayobject.h"
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
+
+    int ob_exports;
+    Py_ssize_t ob_alloc;
+    char *ob_bytes;
+} PyByteArrayObject;
+
+
+extern PyTypeObject PyByteArray_Type;
+extern PyTypeObject PyByteArrayIter_Type;
+
+
+
+
+
+
+PyObject * PyByteArray_FromObject(PyObject *);
+PyObject * PyByteArray_Concat(PyObject *, PyObject *);
+PyObject * PyByteArray_FromStringAndSize(const char *, Py_ssize_t);
+Py_ssize_t PyByteArray_Size(PyObject *);
+char * PyByteArray_AsString(PyObject *);
+int PyByteArray_Resize(PyObject *, Py_ssize_t);
+
+
+
+
+
+
+
+extern char _PyByteArray_empty_string[];
+
+
+}
+# 99 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/tupleobject.h" 1
+
+
+
+
+
+
+extern "C" {
+# 24 "/usr/include/python2.6/tupleobject.h"
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
+    PyObject *ob_item[1];
+
+
+
+
+
+} PyTupleObject;
+
+extern PyTypeObject PyTuple_Type;
+
+
+
+
+
+PyObject * PyTuple_New(Py_ssize_t size);
+Py_ssize_t PyTuple_Size(PyObject *);
+PyObject * PyTuple_GetItem(PyObject *, Py_ssize_t);
+int PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *);
+PyObject * PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
+int _PyTuple_Resize(PyObject **, Py_ssize_t);
+PyObject * PyTuple_Pack(Py_ssize_t, ...);
+# 55 "/usr/include/python2.6/tupleobject.h"
+int PyTuple_ClearFreeList(void);
+
+
+}
+# 100 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/listobject.h" 1
+# 19 "/usr/include/python2.6/listobject.h"
+extern "C" {
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
+
+    PyObject **ob_item;
+# 38 "/usr/include/python2.6/listobject.h"
+    Py_ssize_t allocated;
+} PyListObject;
+
+extern PyTypeObject PyList_Type;
+
+
+
+
+
+PyObject * PyList_New(Py_ssize_t size);
+Py_ssize_t PyList_Size(PyObject *);
+PyObject * PyList_GetItem(PyObject *, Py_ssize_t);
+int PyList_SetItem(PyObject *, Py_ssize_t, PyObject *);
+int PyList_Insert(PyObject *, Py_ssize_t, PyObject *);
+int PyList_Append(PyObject *, PyObject *);
+PyObject * PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t);
+int PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
+int PyList_Sort(PyObject *);
+int PyList_Reverse(PyObject *);
+PyObject * PyList_AsTuple(PyObject *);
+PyObject * _PyList_Extend(PyListObject *, PyObject *);
+
+
+
+
+
+
+
+}
+# 101 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/dictobject.h" 1
+
+
+
+extern "C" {
+# 50 "/usr/include/python2.6/dictobject.h"
+typedef struct {
+
+
+
+
+ Py_ssize_t me_hash;
+ PyObject *me_key;
+ PyObject *me_value;
+} PyDictEntry;
+# 69 "/usr/include/python2.6/dictobject.h"
+typedef struct _dictobject PyDictObject;
+struct _dictobject {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+ Py_ssize_t ma_fill;
+ Py_ssize_t ma_used;
+
+
+
+
+
+ Py_ssize_t ma_mask;
+
+
+
+
+
+
+ PyDictEntry *ma_table;
+ PyDictEntry *(*ma_lookup)(PyDictObject *mp, PyObject *key, long hash);
+ PyDictEntry ma_smalltable[8];
+};
+
+extern PyTypeObject PyDict_Type;
+
+
+
+
+
+PyObject * PyDict_New(void);
+PyObject * PyDict_GetItem(PyObject *mp, PyObject *key);
+int PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item);
+int PyDict_DelItem(PyObject *mp, PyObject *key);
+void PyDict_Clear(PyObject *mp);
+int PyDict_Next(
+ PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value);
+int _PyDict_Next(
+ PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, long *hash);
+PyObject * PyDict_Keys(PyObject *mp);
+PyObject * PyDict_Values(PyObject *mp);
+PyObject * PyDict_Items(PyObject *mp);
+Py_ssize_t PyDict_Size(PyObject *mp);
+PyObject * PyDict_Copy(PyObject *mp);
+int PyDict_Contains(PyObject *mp, PyObject *key);
+int _PyDict_Contains(PyObject *mp, PyObject *key, long hash);
+PyObject * _PyDict_NewPresized(Py_ssize_t minused);
+
+
+int PyDict_Update(PyObject *mp, PyObject *other);
+
+
+
+
+
+
+int PyDict_Merge(PyObject *mp,
+       PyObject *other,
+       int override);
+
+
+
+
+
+
+int PyDict_MergeFromSeq2(PyObject *d,
+        PyObject *seq2,
+        int override);
+
+PyObject * PyDict_GetItemString(PyObject *dp, const char *key);
+int PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item);
+int PyDict_DelItemString(PyObject *dp, const char *key);
+
+
+}
+# 102 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/enumobject.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+extern PyTypeObject PyEnum_Type;
+extern PyTypeObject PyReversed_Type;
+
+
+}
+# 103 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/setobject.h" 1
+
+
+
+
+
+extern "C" {
+# 24 "/usr/include/python2.6/setobject.h"
+typedef struct {
+ long hash;
+ PyObject *key;
+} setentry;
+
+
+
+
+
+
+typedef struct _setobject PySetObject;
+struct _setobject {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+
+ Py_ssize_t fill;
+ Py_ssize_t used;
+
+
+
+
+
+ Py_ssize_t mask;
+
+
+
+
+
+ setentry *table;
+ setentry *(*lookup)(PySetObject *so, PyObject *key, long hash);
+ setentry smalltable[8];
+
+ long hash;
+ PyObject *weakreflist;
+};
+
+extern PyTypeObject PySet_Type;
+extern PyTypeObject PyFrozenSet_Type;
+# 83 "/usr/include/python2.6/setobject.h"
+PyObject * PySet_New(PyObject *);
+PyObject * PyFrozenSet_New(PyObject *);
+Py_ssize_t PySet_Size(PyObject *anyset);
+
+int PySet_Clear(PyObject *set);
+int PySet_Contains(PyObject *anyset, PyObject *key);
+int PySet_Discard(PyObject *set, PyObject *key);
+int PySet_Add(PyObject *set, PyObject *key);
+int _PySet_Next(PyObject *set, Py_ssize_t *pos, PyObject **key);
+int _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, long *hash);
+PyObject * PySet_Pop(PyObject *set);
+int _PySet_Update(PyObject *set, PyObject *iterable);
+
+
+}
+# 104 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/methodobject.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+
+
+extern PyTypeObject PyCFunction_Type;
+
+
+
+typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
+typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *,
+          PyObject *);
+typedef PyObject *(*PyNoArgsFunction)(PyObject *);
+
+PyCFunction PyCFunction_GetFunction(PyObject *);
+PyObject * PyCFunction_GetSelf(PyObject *);
+int PyCFunction_GetFlags(PyObject *);
+# 35 "/usr/include/python2.6/methodobject.h"
+PyObject * PyCFunction_Call(PyObject *, PyObject *, PyObject *);
+
+struct PyMethodDef {
+    const char *ml_name;
+    PyCFunction ml_meth;
+    int ml_flags;
+
+    const char *ml_doc;
+};
+typedef struct PyMethodDef PyMethodDef;
+
+PyObject * Py_FindMethod(PyMethodDef[], PyObject *, const char *);
+
+
+PyObject * PyCFunction_NewEx(PyMethodDef *, PyObject *,
+      PyObject *);
+# 73 "/usr/include/python2.6/methodobject.h"
+typedef struct PyMethodChain {
+    PyMethodDef *methods;
+    struct PyMethodChain *link;
+} PyMethodChain;
+
+PyObject * Py_FindMethodInChain(PyMethodChain *, PyObject *,
+                                            const char *);
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyMethodDef *m_ml;
+    PyObject *m_self;
+    PyObject *m_module;
+} PyCFunctionObject;
+
+int PyCFunction_ClearFreeList(void);
+
+
+}
+# 105 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/moduleobject.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+extern PyTypeObject PyModule_Type;
+
+
+
+
+PyObject * PyModule_New(const char *);
+PyObject * PyModule_GetDict(PyObject *);
+char * PyModule_GetName(PyObject *);
+char * PyModule_GetFilename(PyObject *);
+void _PyModule_Clear(PyObject *);
+
+
+}
+# 106 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/funcobject.h" 1
+
+
+
+
+
+
+extern "C" {
+# 21 "/usr/include/python2.6/funcobject.h"
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *func_code;
+    PyObject *func_globals;
+    PyObject *func_defaults;
+    PyObject *func_closure;
+    PyObject *func_doc;
+    PyObject *func_name;
+    PyObject *func_dict;
+    PyObject *func_weakreflist;
+    PyObject *func_module;
+
+
+
+
+
+
+} PyFunctionObject;
+
+extern PyTypeObject PyFunction_Type;
+
+
+
+PyObject * PyFunction_New(PyObject *, PyObject *);
+PyObject * PyFunction_GetCode(PyObject *);
+PyObject * PyFunction_GetGlobals(PyObject *);
+PyObject * PyFunction_GetModule(PyObject *);
+PyObject * PyFunction_GetDefaults(PyObject *);
+int PyFunction_SetDefaults(PyObject *, PyObject *);
+PyObject * PyFunction_GetClosure(PyObject *);
+int PyFunction_SetClosure(PyObject *, PyObject *);
+# 67 "/usr/include/python2.6/funcobject.h"
+extern PyTypeObject PyClassMethod_Type;
+extern PyTypeObject PyStaticMethod_Type;
+
+PyObject * PyClassMethod_New(PyObject *);
+PyObject * PyStaticMethod_New(PyObject *);
+
+
+}
+# 107 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/classobject.h" 1
+# 9 "/usr/include/python2.6/classobject.h"
+extern "C" {
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *cl_bases;
+    PyObject *cl_dict;
+    PyObject *cl_name;
+
+    PyObject *cl_getattr;
+    PyObject *cl_setattr;
+    PyObject *cl_delattr;
+} PyClassObject;
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyClassObject *in_class;
+    PyObject *in_dict;
+    PyObject *in_weakreflist;
+} PyInstanceObject;
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *im_func;
+    PyObject *im_self;
+    PyObject *im_class;
+    PyObject *im_weakreflist;
+} PyMethodObject;
+
+extern PyTypeObject PyClass_Type, PyInstance_Type, PyMethod_Type;
+
+
+
+
+
+PyObject * PyClass_New(PyObject *, PyObject *, PyObject *);
+PyObject * PyInstance_New(PyObject *, PyObject *,
+                                            PyObject *);
+PyObject * PyInstance_NewRaw(PyObject *, PyObject *);
+PyObject * PyMethod_New(PyObject *, PyObject *, PyObject *);
+
+PyObject * PyMethod_Function(PyObject *);
+PyObject * PyMethod_Self(PyObject *);
+PyObject * PyMethod_Class(PyObject *);
+# 64 "/usr/include/python2.6/classobject.h"
+PyObject * _PyInstance_Lookup(PyObject *pinst, PyObject *name);
+# 75 "/usr/include/python2.6/classobject.h"
+int PyClass_IsSubclass(PyObject *, PyObject *);
+
+int PyMethod_ClearFreeList(void);
+
+
+}
+# 108 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/fileobject.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+ FILE *f_fp;
+ PyObject *f_name;
+ PyObject *f_mode;
+ int (*f_close)(FILE *);
+ int f_softspace;
+ int f_binary;
+
+ char* f_buf;
+ char* f_bufend;
+ char* f_bufptr;
+ char *f_setbuf;
+ int f_univ_newline;
+ int f_newlinetypes;
+ int f_skipnextlf;
+ PyObject *f_encoding;
+ PyObject *f_errors;
+ PyObject *weakreflist;
+ int unlocked_count;
+
+ int readable;
+ int writable;
+} PyFileObject;
+
+extern PyTypeObject PyFile_Type;
+
+
+
+
+PyObject * PyFile_FromString(char *, char *);
+void PyFile_SetBufSize(PyObject *, int);
+int PyFile_SetEncoding(PyObject *, const char *);
+int PyFile_SetEncodingAndErrors(PyObject *, const char *, char *errors);
+PyObject * PyFile_FromFile(FILE *, char *, char *,
+                                             int (*)(FILE *));
+FILE * PyFile_AsFile(PyObject *);
+void PyFile_IncUseCount(PyFileObject *);
+void PyFile_DecUseCount(PyFileObject *);
+PyObject * PyFile_Name(PyObject *);
+PyObject * PyFile_GetLine(PyObject *, int);
+int PyFile_WriteObject(PyObject *, PyObject *, int);
+int PyFile_SoftSpace(PyObject *, int);
+int PyFile_WriteString(const char *, PyObject *);
+int PyObject_AsFileDescriptor(PyObject *);
+
+
+
+
+extern const char * Py_FileSystemDefaultEncoding;
+
+
+
+
+
+char *Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *);
+size_t Py_UniversalNewlineFread(char *, size_t, FILE *, PyObject *);
+
+
+
+
+int _PyFile_SanitizeMode(char *mode);
+
+
+}
+# 109 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/cobject.h" 1
+# 14 "/usr/include/python2.6/cobject.h"
+extern "C" {
+
+
+extern PyTypeObject PyCObject_Type;
+# 27 "/usr/include/python2.6/cobject.h"
+PyObject * PyCObject_FromVoidPtr(
+ void *cobj, void (*destruct)(void*));
+
+
+
+
+
+
+
+PyObject * PyCObject_FromVoidPtrAndDesc(
+ void *cobj, void *desc, void (*destruct)(void*,void*));
+
+
+void * PyCObject_AsVoidPtr(PyObject *);
+
+
+void * PyCObject_GetDesc(PyObject *);
+
+
+void * PyCObject_Import(char *module_name, char *cobject_name);
+
+
+int PyCObject_SetVoidPtr(PyObject *self, void *cobj);
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    void *cobject;
+    void *desc;
+    void (*destructor)(void *);
+} PyCObject;
+
+
+
+}
+# 110 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/traceback.h" 1
+
+
+
+
+extern "C" {
+
+
+struct _frame;
+
+
+
+typedef struct _traceback {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+ struct _traceback *tb_next;
+ struct _frame *tb_frame;
+ int tb_lasti;
+ int tb_lineno;
+} PyTracebackObject;
+
+int PyTraceBack_Here(struct _frame *);
+int PyTraceBack_Print(PyObject *, PyObject *);
+int _Py_DisplaySourceLine(PyObject *, const char *, int, int);
+
+
+extern PyTypeObject PyTraceBack_Type;
+
+
+
+}
+# 111 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/sliceobject.h" 1
+
+
+
+extern "C" {
+
+
+
+
+extern PyObject _Py_EllipsisObject;
+# 22 "/usr/include/python2.6/sliceobject.h"
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *start, *stop, *step;
+} PySliceObject;
+
+extern PyTypeObject PySlice_Type;
+extern PyTypeObject PyEllipsis_Type;
+
+
+
+PyObject * PySlice_New(PyObject* start, PyObject* stop,
+                                  PyObject* step);
+PyObject * _PySlice_FromIndices(Py_ssize_t start, Py_ssize_t stop);
+int PySlice_GetIndices(PySliceObject *r, Py_ssize_t length,
+                                  Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step);
+int PySlice_GetIndicesEx(PySliceObject *r, Py_ssize_t length,
+        Py_ssize_t *start, Py_ssize_t *stop,
+        Py_ssize_t *step, Py_ssize_t *slicelength);
+
+
+}
+# 112 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/cellobject.h" 1
+
+
+
+
+
+extern "C" {
+
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+ PyObject *ob_ref;
+} PyCellObject;
+
+extern PyTypeObject PyCell_Type;
+
+
+
+PyObject * PyCell_New(PyObject *);
+PyObject * PyCell_Get(PyObject *);
+int PyCell_Set(PyObject *, PyObject *);
+
+
+
+
+
+}
+# 113 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/iterobject.h" 1
+
+
+
+
+extern "C" {
+
+
+extern PyTypeObject PySeqIter_Type;
+
+
+
+PyObject * PySeqIter_New(PyObject *);
+
+extern PyTypeObject PyCallIter_Type;
+
+
+
+PyObject * PyCallIter_New(PyObject *, PyObject *);
+
+}
+# 114 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/genobject.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+struct _frame;
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+
+
+
+ struct _frame *gi_frame;
+
+
+ int gi_running;
+
+
+ PyObject *gi_code;
+
+
+ PyObject *gi_weakreflist;
+} PyGenObject;
+
+extern PyTypeObject PyGen_Type;
+
+
+
+
+PyObject * PyGen_New(struct _frame *);
+int PyGen_NeedsFinalizing(PyGenObject *);
+
+
+}
+# 115 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/descrobject.h" 1
+
+
+
+
+extern "C" {
+
+
+typedef PyObject *(*getter)(PyObject *, void *);
+typedef int (*setter)(PyObject *, PyObject *, void *);
+
+typedef struct PyGetSetDef {
+ char *name;
+ getter get;
+ setter set;
+ char *doc;
+ void *closure;
+} PyGetSetDef;
+
+typedef PyObject *(*wrapperfunc)(PyObject *self, PyObject *args,
+     void *wrapped);
+
+typedef PyObject *(*wrapperfunc_kwds)(PyObject *self, PyObject *args,
+          void *wrapped, PyObject *kwds);
+
+struct wrapperbase {
+ char *name;
+ int offset;
+ void *function;
+ wrapperfunc wrapper;
+ char *doc;
+ int flags;
+ PyObject *name_strobj;
+};
+# 45 "/usr/include/python2.6/descrobject.h"
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
+} PyDescrObject;
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
+ PyMethodDef *d_method;
+} PyMethodDescrObject;
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
+ struct PyMemberDef *d_member;
+} PyMemberDescrObject;
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
+ PyGetSetDef *d_getset;
+} PyGetSetDescrObject;
+
+typedef struct {
+ Py_ssize_t ob_refcnt; struct _typeobject *ob_type; PyTypeObject *d_type; PyObject *d_name;
+ struct wrapperbase *d_base;
+ void *d_wrapped;
+} PyWrapperDescrObject;
+
+extern PyTypeObject PyWrapperDescr_Type;
+extern PyTypeObject PyDictProxy_Type;
+extern PyTypeObject PyGetSetDescr_Type;
+extern PyTypeObject PyMemberDescr_Type;
+
+PyObject * PyDescr_NewMethod(PyTypeObject *, PyMethodDef *);
+PyObject * PyDescr_NewClassMethod(PyTypeObject *, PyMethodDef *);
+PyObject * PyDescr_NewMember(PyTypeObject *,
+            struct PyMemberDef *);
+PyObject * PyDescr_NewGetSet(PyTypeObject *,
+            struct PyGetSetDef *);
+PyObject * PyDescr_NewWrapper(PyTypeObject *,
+      struct wrapperbase *, void *);
+
+
+PyObject * PyDictProxy_New(PyObject *);
+PyObject * PyWrapper_New(PyObject *, PyObject *);
+
+
+extern PyTypeObject PyProperty_Type;
+
+}
+# 116 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/warnings.h" 1
+
+
+
+extern "C" {
+
+
+void _PyWarnings_Init(void);
+
+int PyErr_WarnEx(PyObject *, const char *, Py_ssize_t);
+int PyErr_WarnExplicit(PyObject *, const char *, const char *, int,
+                                    const char *, PyObject *);
+# 20 "/usr/include/python2.6/warnings.h"
+}
+# 117 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/weakrefobject.h" 1
+
+
+
+
+
+extern "C" {
+
+
+
+typedef struct _PyWeakReference PyWeakReference;
+
+
+
+
+struct _PyWeakReference {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+
+
+
+
+
+    PyObject *wr_object;
+
+
+    PyObject *wr_callback;
+
+
+
+
+    long hash;
+
+
+
+
+
+
+    PyWeakReference *wr_prev;
+    PyWeakReference *wr_next;
+};
+
+extern PyTypeObject _PyWeakref_RefType;
+extern PyTypeObject _PyWeakref_ProxyType;
+extern PyTypeObject _PyWeakref_CallableProxyType;
+# 59 "/usr/include/python2.6/weakrefobject.h"
+PyObject * PyWeakref_NewRef(PyObject *ob,
+                                              PyObject *callback);
+PyObject * PyWeakref_NewProxy(PyObject *ob,
+                                                PyObject *callback);
+PyObject * PyWeakref_GetObject(PyObject *ref);
+
+Py_ssize_t _PyWeakref_GetWeakrefCount(PyWeakReference *head);
+
+void _PyWeakref_ClearRef(PyWeakReference *self);
+
+
+
+
+
+}
+# 118 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/codecs.h" 1
+
+
+
+extern "C" {
+# 26 "/usr/include/python2.6/codecs.h"
+int PyCodec_Register(
+       PyObject *search_function
+       );
+# 48 "/usr/include/python2.6/codecs.h"
+PyObject * _PyCodec_Lookup(
+       const char *encoding
+       );
+# 62 "/usr/include/python2.6/codecs.h"
+PyObject * PyCodec_Encode(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+# 78 "/usr/include/python2.6/codecs.h"
+PyObject * PyCodec_Decode(
+       PyObject *object,
+       const char *encoding,
+       const char *errors
+       );
+# 94 "/usr/include/python2.6/codecs.h"
+PyObject * PyCodec_Encoder(
+       const char *encoding
+       );
+
+
+
+PyObject * PyCodec_Decoder(
+       const char *encoding
+       );
+
+
+
+PyObject * PyCodec_IncrementalEncoder(
+       const char *encoding,
+       const char *errors
+       );
+
+
+
+PyObject * PyCodec_IncrementalDecoder(
+       const char *encoding,
+       const char *errors
+       );
+
+
+
+PyObject * PyCodec_StreamReader(
+       const char *encoding,
+       PyObject *stream,
+       const char *errors
+       );
+
+
+
+PyObject * PyCodec_StreamWriter(
+       const char *encoding,
+       PyObject *stream,
+       const char *errors
+       );
+# 142 "/usr/include/python2.6/codecs.h"
+int PyCodec_RegisterError(const char *name, PyObject *error);
+
+
+
+
+PyObject * PyCodec_LookupError(const char *name);
+
+
+PyObject * PyCodec_StrictErrors(PyObject *exc);
+
+
+PyObject * PyCodec_IgnoreErrors(PyObject *exc);
+
+
+PyObject * PyCodec_ReplaceErrors(PyObject *exc);
+
+
+PyObject * PyCodec_XMLCharRefReplaceErrors(PyObject *exc);
+
+
+PyObject * PyCodec_BackslashReplaceErrors(PyObject *exc);
+
+
+}
+# 120 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/pyerrors.h" 1
+
+
+
+extern "C" {
+
+
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *dict;
+    PyObject *args;
+    PyObject *message;
+} PyBaseExceptionObject;
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *dict;
+    PyObject *args;
+    PyObject *message;
+    PyObject *msg;
+    PyObject *filename;
+    PyObject *lineno;
+    PyObject *offset;
+    PyObject *text;
+    PyObject *print_file_and_line;
+} PySyntaxErrorObject;
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *dict;
+    PyObject *args;
+    PyObject *message;
+    PyObject *encoding;
+    PyObject *object;
+    Py_ssize_t start;
+    Py_ssize_t end;
+    PyObject *reason;
+} PyUnicodeErrorObject;
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *dict;
+    PyObject *args;
+    PyObject *message;
+    PyObject *code;
+} PySystemExitObject;
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    PyObject *dict;
+    PyObject *args;
+    PyObject *message;
+    PyObject *myerrno;
+    PyObject *strerror;
+    PyObject *filename;
+} PyEnvironmentErrorObject;
+# 76 "/usr/include/python2.6/pyerrors.h"
+void PyErr_SetNone(PyObject *);
+void PyErr_SetObject(PyObject *, PyObject *);
+void PyErr_SetString(PyObject *, const char *);
+PyObject * PyErr_Occurred(void);
+void PyErr_Clear(void);
+void PyErr_Fetch(PyObject **, PyObject **, PyObject **);
+void PyErr_Restore(PyObject *, PyObject *, PyObject *);
+# 91 "/usr/include/python2.6/pyerrors.h"
+int PyErr_GivenExceptionMatches(PyObject *, PyObject *);
+int PyErr_ExceptionMatches(PyObject *);
+void PyErr_NormalizeException(PyObject**, PyObject**, PyObject**);
+# 118 "/usr/include/python2.6/pyerrors.h"
+extern PyObject * PyExc_BaseException;
+extern PyObject * PyExc_Exception;
+extern PyObject * PyExc_StopIteration;
+extern PyObject * PyExc_GeneratorExit;
+extern PyObject * PyExc_StandardError;
+extern PyObject * PyExc_ArithmeticError;
+extern PyObject * PyExc_LookupError;
+
+extern PyObject * PyExc_AssertionError;
+extern PyObject * PyExc_AttributeError;
+extern PyObject * PyExc_EOFError;
+extern PyObject * PyExc_FloatingPointError;
+extern PyObject * PyExc_EnvironmentError;
+extern PyObject * PyExc_IOError;
+extern PyObject * PyExc_OSError;
+extern PyObject * PyExc_ImportError;
+extern PyObject * PyExc_IndexError;
+extern PyObject * PyExc_KeyError;
+extern PyObject * PyExc_KeyboardInterrupt;
+extern PyObject * PyExc_MemoryError;
+extern PyObject * PyExc_NameError;
+extern PyObject * PyExc_OverflowError;
+extern PyObject * PyExc_RuntimeError;
+extern PyObject * PyExc_NotImplementedError;
+extern PyObject * PyExc_SyntaxError;
+extern PyObject * PyExc_IndentationError;
+extern PyObject * PyExc_TabError;
+extern PyObject * PyExc_ReferenceError;
+extern PyObject * PyExc_SystemError;
+extern PyObject * PyExc_SystemExit;
+extern PyObject * PyExc_TypeError;
+extern PyObject * PyExc_UnboundLocalError;
+extern PyObject * PyExc_UnicodeError;
+extern PyObject * PyExc_UnicodeEncodeError;
+extern PyObject * PyExc_UnicodeDecodeError;
+extern PyObject * PyExc_UnicodeTranslateError;
+extern PyObject * PyExc_ValueError;
+extern PyObject * PyExc_ZeroDivisionError;
+
+
+
+
+
+
+
+extern PyObject * PyExc_BufferError;
+
+extern PyObject * PyExc_MemoryErrorInst;
+extern PyObject * PyExc_RecursionErrorInst;
+
+
+extern PyObject * PyExc_Warning;
+extern PyObject * PyExc_UserWarning;
+extern PyObject * PyExc_DeprecationWarning;
+extern PyObject * PyExc_PendingDeprecationWarning;
+extern PyObject * PyExc_SyntaxWarning;
+extern PyObject * PyExc_RuntimeWarning;
+extern PyObject * PyExc_FutureWarning;
+extern PyObject * PyExc_ImportWarning;
+extern PyObject * PyExc_UnicodeWarning;
+extern PyObject * PyExc_BytesWarning;
+
+
+
+
+int PyErr_BadArgument(void);
+PyObject * PyErr_NoMemory(void);
+PyObject * PyErr_SetFromErrno(PyObject *);
+PyObject * PyErr_SetFromErrnoWithFilenameObject(
+ PyObject *, PyObject *);
+PyObject * PyErr_SetFromErrnoWithFilename(PyObject *, char *);
+
+
+
+
+
+PyObject * PyErr_Format(PyObject *, const char *, ...)
+   __attribute__((format(printf, 2, 3)));
+# 219 "/usr/include/python2.6/pyerrors.h"
+void PyErr_BadInternalCall(void);
+void _PyErr_BadInternalCall(char *filename, int lineno);
+
+
+
+
+
+PyObject * PyErr_NewException(char *name, PyObject *base,
+                                         PyObject *dict);
+void PyErr_WriteUnraisable(PyObject *);
+
+
+int PyErr_CheckSignals(void);
+void PyErr_SetInterrupt(void);
+
+
+int PySignal_SetWakeupFd(int fd);
+
+
+void PyErr_SyntaxLocation(const char *, int);
+PyObject * PyErr_ProgramText(const char *, int);
+
+
+
+
+
+
+PyObject * PyUnicodeDecodeError_Create(
+ const char *, const char *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+
+
+PyObject * PyUnicodeEncodeError_Create(
+ const char *, const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+
+
+PyObject * PyUnicodeTranslateError_Create(
+ const Py_UNICODE *, Py_ssize_t, Py_ssize_t, Py_ssize_t, const char *);
+
+
+PyObject * PyUnicodeEncodeError_GetEncoding(PyObject *);
+PyObject * PyUnicodeDecodeError_GetEncoding(PyObject *);
+
+
+PyObject * PyUnicodeEncodeError_GetObject(PyObject *);
+PyObject * PyUnicodeDecodeError_GetObject(PyObject *);
+PyObject * PyUnicodeTranslateError_GetObject(PyObject *);
+
+
+
+int PyUnicodeEncodeError_GetStart(PyObject *, Py_ssize_t *);
+int PyUnicodeDecodeError_GetStart(PyObject *, Py_ssize_t *);
+int PyUnicodeTranslateError_GetStart(PyObject *, Py_ssize_t *);
+
+
+
+int PyUnicodeEncodeError_SetStart(PyObject *, Py_ssize_t);
+int PyUnicodeDecodeError_SetStart(PyObject *, Py_ssize_t);
+int PyUnicodeTranslateError_SetStart(PyObject *, Py_ssize_t);
+
+
+
+int PyUnicodeEncodeError_GetEnd(PyObject *, Py_ssize_t *);
+int PyUnicodeDecodeError_GetEnd(PyObject *, Py_ssize_t *);
+int PyUnicodeTranslateError_GetEnd(PyObject *, Py_ssize_t *);
+
+
+
+int PyUnicodeEncodeError_SetEnd(PyObject *, Py_ssize_t);
+int PyUnicodeDecodeError_SetEnd(PyObject *, Py_ssize_t);
+int PyUnicodeTranslateError_SetEnd(PyObject *, Py_ssize_t);
+
+
+PyObject * PyUnicodeEncodeError_GetReason(PyObject *);
+PyObject * PyUnicodeDecodeError_GetReason(PyObject *);
+PyObject * PyUnicodeTranslateError_GetReason(PyObject *);
+
+
+
+int PyUnicodeEncodeError_SetReason(
+ PyObject *, const char *);
+int PyUnicodeDecodeError_SetReason(
+ PyObject *, const char *);
+int PyUnicodeTranslateError_SetReason(
+ PyObject *, const char *);
+# 321 "/usr/include/python2.6/pyerrors.h"
+int PyOS_snprintf(char *str, size_t size, const char *format, ...)
+   __attribute__((format(printf, 3, 4)));
+int PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
+   __attribute__((format(printf, 3, 0)));
+
+
+}
+# 121 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/pystate.h" 1
+
+
+
+
+
+
+
+extern "C" {
+
+
+
+
+struct _ts;
+struct _is;
+
+typedef struct _is {
+
+    struct _is *next;
+    struct _ts *tstate_head;
+
+    PyObject *modules;
+    PyObject *sysdict;
+    PyObject *builtins;
+    PyObject *modules_reloading;
+
+    PyObject *codec_search_path;
+    PyObject *codec_search_cache;
+    PyObject *codec_error_registry;
+
+
+    int dlopenflags;
+
+
+
+
+
+} PyInterpreterState;
+
+
+
+
+struct _frame;
+
+
+typedef int (*Py_tracefunc)(PyObject *, struct _frame *, int, PyObject *);
+# 56 "/usr/include/python2.6/pystate.h"
+typedef struct _ts {
+
+
+    struct _ts *next;
+    PyInterpreterState *interp;
+
+    struct _frame *frame;
+    int recursion_depth;
+
+
+
+    int tracing;
+    int use_tracing;
+
+    Py_tracefunc c_profilefunc;
+    Py_tracefunc c_tracefunc;
+    PyObject *c_profileobj;
+    PyObject *c_traceobj;
+
+    PyObject *curexc_type;
+    PyObject *curexc_value;
+    PyObject *curexc_traceback;
+
+    PyObject *exc_type;
+    PyObject *exc_value;
+    PyObject *exc_traceback;
+
+    PyObject *dict;
+
+
+
+
+
+
+
+    int tick_counter;
+
+    int gilstate_counter;
+
+    PyObject *async_exc;
+    long thread_id;
+
+
+
+} PyThreadState;
+
+
+PyInterpreterState * PyInterpreterState_New(void);
+void PyInterpreterState_Clear(PyInterpreterState *);
+void PyInterpreterState_Delete(PyInterpreterState *);
+
+PyThreadState * PyThreadState_New(PyInterpreterState *);
+PyThreadState * _PyThreadState_Prealloc(PyInterpreterState *);
+void _PyThreadState_Init(PyThreadState *);
+void PyThreadState_Clear(PyThreadState *);
+void PyThreadState_Delete(PyThreadState *);
+
+void PyThreadState_DeleteCurrent(void);
+
+
+PyThreadState * PyThreadState_Get(void);
+PyThreadState * PyThreadState_Swap(PyThreadState *);
+PyObject * PyThreadState_GetDict(void);
+int PyThreadState_SetAsyncExc(long, PyObject *);
+
+
+
+
+extern PyThreadState * _PyThreadState_Current;
+
+
+
+
+
+
+
+typedef
+    enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
+        PyGILState_STATE;
+# 157 "/usr/include/python2.6/pystate.h"
+PyGILState_STATE PyGILState_Ensure(void);
+# 167 "/usr/include/python2.6/pystate.h"
+void PyGILState_Release(PyGILState_STATE);
+
+
+
+
+
+
+
+PyThreadState * PyGILState_GetThisThreadState(void);
+
+
+
+
+PyObject * _PyThread_CurrentFrames(void);
+
+
+
+PyInterpreterState * PyInterpreterState_Head(void);
+PyInterpreterState * PyInterpreterState_Next(PyInterpreterState *);
+PyThreadState * PyInterpreterState_ThreadHead(PyInterpreterState *);
+PyThreadState * PyThreadState_Next(PyThreadState *);
+
+typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_);
+
+
+extern PyThreadFrameGetter _PyThreadState_GetFrame;
+
+
+}
+# 123 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/pyarena.h" 1
+
+
+
+
+
+
+
+extern "C" {
+
+
+  typedef struct _arena PyArena;
+# 35 "/usr/include/python2.6/pyarena.h"
+  PyArena * PyArena_New(void);
+  void PyArena_Free(PyArena *);
+# 50 "/usr/include/python2.6/pyarena.h"
+  void * PyArena_Malloc(PyArena *, size_t size);
+
+
+
+
+
+  int PyArena_AddPyObject(PyArena *, PyObject *);
+
+
+}
+# 125 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/modsupport.h" 1
+
+
+
+
+extern "C" {
+# 23 "/usr/include/python2.6/modsupport.h"
+PyObject * _Py_VaBuildValue_SizeT(const char *, va_list);
+
+
+int PyArg_Parse(PyObject *, const char *, ...);
+int PyArg_ParseTuple(PyObject *, const char *, ...) ;
+int PyArg_ParseTupleAndKeywords(PyObject *, PyObject *,
+                                                  const char *, char **, ...);
+int PyArg_UnpackTuple(PyObject *, const char *, Py_ssize_t, Py_ssize_t, ...);
+PyObject * Py_BuildValue(const char *, ...);
+PyObject * _Py_BuildValue_SizeT(const char *, ...);
+int _PyArg_NoKeywords(const char *funcname, PyObject *kw);
+
+int PyArg_VaParse(PyObject *, const char *, va_list);
+int PyArg_VaParseTupleAndKeywords(PyObject *, PyObject *,
+                                                  const char *, char **, va_list);
+PyObject * Py_VaBuildValue(const char *, va_list);
+
+int PyModule_AddObject(PyObject *, const char *, PyObject *);
+int PyModule_AddIntConstant(PyObject *, const char *, long);
+int PyModule_AddStringConstant(PyObject *, const char *, const char *);
+# 117 "/usr/include/python2.6/modsupport.h"
+PyObject * Py_InitModule4_64(const char *name, PyMethodDef *methods,
+                                      const char *doc, PyObject *self,
+                                      int apiver);
+# 129 "/usr/include/python2.6/modsupport.h"
+extern char * _Py_PackageContext;
+
+
+}
+# 126 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/pythonrun.h" 1
+
+
+
+
+
+
+extern "C" {
+# 18 "/usr/include/python2.6/pythonrun.h"
+typedef struct {
+ int cf_flags;
+} PyCompilerFlags;
+
+void Py_SetProgramName(char *);
+char * Py_GetProgramName(void);
+
+void Py_SetPythonHome(char *);
+char * Py_GetPythonHome(void);
+
+void Py_Initialize(void);
+void Py_InitializeEx(int);
+void Py_Finalize(void);
+int Py_IsInitialized(void);
+PyThreadState * Py_NewInterpreter(void);
+void Py_EndInterpreter(PyThreadState *);
+
+int PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *);
+int PyRun_AnyFileExFlags(FILE *, const char *, int, PyCompilerFlags *);
+int PyRun_SimpleStringFlags(const char *, PyCompilerFlags *);
+int PyRun_SimpleFileExFlags(FILE *, const char *, int, PyCompilerFlags *);
+int PyRun_InteractiveOneFlags(FILE *, const char *, PyCompilerFlags *);
+int PyRun_InteractiveLoopFlags(FILE *, const char *, PyCompilerFlags *);
+
+struct _mod * PyParser_ASTFromString(const char *, const char *,
+       int, PyCompilerFlags *flags,
+                                                 PyArena *);
+struct _mod * PyParser_ASTFromFile(FILE *, const char *, int,
+            char *, char *,
+                                               PyCompilerFlags *, int *,
+                                               PyArena *);
+
+
+
+
+struct _node * PyParser_SimpleParseStringFlags(const char *, int,
+         int);
+struct _node * PyParser_SimpleParseFileFlags(FILE *, const char *,
+       int, int);
+
+PyObject * PyRun_StringFlags(const char *, int, PyObject *,
+      PyObject *, PyCompilerFlags *);
+
+PyObject * PyRun_FileExFlags(FILE *, const char *, int,
+      PyObject *, PyObject *, int,
+      PyCompilerFlags *);
+
+
+PyObject * Py_CompileStringFlags(const char *, const char *, int,
+          PyCompilerFlags *);
+struct symtable * Py_SymtableString(const char *, const char *, int);
+
+void PyErr_Print(void);
+void PyErr_PrintEx(int);
+void PyErr_Display(PyObject *, PyObject *, PyObject *);
+
+int Py_AtExit(void (*func)(void));
+
+void Py_Exit(int);
+
+int Py_FdIsInteractive(FILE *, const char *);
+
+
+int Py_Main(int argc, char **argv);
+# 103 "/usr/include/python2.6/pythonrun.h"
+char * Py_GetProgramFullPath(void);
+char * Py_GetPrefix(void);
+char * Py_GetExecPrefix(void);
+char * Py_GetPath(void);
+
+
+const char * Py_GetVersion(void);
+const char * Py_GetPlatform(void);
+const char * Py_GetCopyright(void);
+const char * Py_GetCompiler(void);
+const char * Py_GetBuildInfo(void);
+const char * _Py_svnversion(void);
+const char * Py_SubversionRevision(void);
+const char * Py_SubversionShortBranch(void);
+
+
+PyObject * _PyBuiltin_Init(void);
+PyObject * _PySys_Init(void);
+void _PyImport_Init(void);
+void _PyExc_Init(void);
+void _PyImportHooks_Init(void);
+int _PyFrame_Init(void);
+int _PyInt_Init(void);
+void _PyFloat_Init(void);
+int PyByteArray_Init(void);
+
+
+void _PyExc_Fini(void);
+void _PyImport_Fini(void);
+void PyMethod_Fini(void);
+void PyFrame_Fini(void);
+void PyCFunction_Fini(void);
+void PyDict_Fini(void);
+void PyTuple_Fini(void);
+void PyList_Fini(void);
+void PySet_Fini(void);
+void PyString_Fini(void);
+void PyInt_Fini(void);
+void PyFloat_Fini(void);
+void PyOS_FiniInterrupts(void);
+void PyByteArray_Fini(void);
+
+
+char * PyOS_Readline(FILE *, FILE *, char *);
+extern int (*PyOS_InputHook)(void);
+extern char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, char *);
+extern PyThreadState* _PyOS_ReadlineTState;
+# 167 "/usr/include/python2.6/pythonrun.h"
+typedef void (*PyOS_sighandler_t)(int);
+PyOS_sighandler_t PyOS_getsig(int);
+PyOS_sighandler_t PyOS_setsig(int, PyOS_sighandler_t);
+
+
+
+}
+# 127 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/ceval.h" 1
+
+
+
+extern "C" {
+
+
+
+
+
+PyObject * PyEval_CallObjectWithKeywords(
+ PyObject *, PyObject *, PyObject *);
+
+
+
+PyObject * PyEval_CallObject(PyObject *, PyObject *);
+
+
+
+
+
+PyObject * PyEval_CallFunction(PyObject *obj,
+                                           const char *format, ...);
+PyObject * PyEval_CallMethod(PyObject *obj,
+                                         const char *methodname,
+                                         const char *format, ...);
+
+void PyEval_SetProfile(Py_tracefunc, PyObject *);
+void PyEval_SetTrace(Py_tracefunc, PyObject *);
+
+struct _frame;
+
+PyObject * PyEval_GetBuiltins(void);
+PyObject * PyEval_GetGlobals(void);
+PyObject * PyEval_GetLocals(void);
+struct _frame * PyEval_GetFrame(void);
+int PyEval_GetRestricted(void);
+
+
+
+
+int PyEval_MergeCompilerFlags(PyCompilerFlags *cf);
+
+int Py_FlushLine(void);
+
+int Py_AddPendingCall(int (*func)(void *), void *arg);
+int Py_MakePendingCalls(void);
+
+
+void Py_SetRecursionLimit(int);
+int Py_GetRecursionLimit(void);
+
+
+
+
+
+
+int _Py_CheckRecursiveCall(char *where);
+extern int _Py_CheckRecursionLimit;
+
+
+
+
+
+
+const char * PyEval_GetFuncName(PyObject *);
+const char * PyEval_GetFuncDesc(PyObject *);
+
+PyObject * PyEval_GetCallStats(PyObject *);
+PyObject * PyEval_EvalFrame(struct _frame *);
+PyObject * PyEval_EvalFrameEx(struct _frame *f, int exc);
+
+
+extern volatile int _Py_Ticker;
+extern int _Py_CheckInterval;
+# 121 "/usr/include/python2.6/ceval.h"
+PyThreadState * PyEval_SaveThread(void);
+void PyEval_RestoreThread(PyThreadState *);
+
+
+
+int PyEval_ThreadsInitialized(void);
+void PyEval_InitThreads(void);
+void PyEval_AcquireLock(void);
+void PyEval_ReleaseLock(void);
+void PyEval_AcquireThread(PyThreadState *tstate);
+void PyEval_ReleaseThread(PyThreadState *tstate);
+void PyEval_ReInitThreads(void);
+# 151 "/usr/include/python2.6/ceval.h"
+int _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
+
+
+
+}
+# 128 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/sysmodule.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+PyObject * PySys_GetObject(char *);
+int PySys_SetObject(char *, PyObject *);
+FILE * PySys_GetFile(char *, FILE *);
+void PySys_SetArgv(int, char **);
+void PySys_SetPath(char *);
+
+void PySys_WriteStdout(const char *format, ...)
+   __attribute__((format(printf, 1, 2)));
+void PySys_WriteStderr(const char *format, ...)
+   __attribute__((format(printf, 1, 2)));
+
+extern PyObject * _PySys_TraceFunc, *_PySys_ProfileFunc;
+extern int _PySys_CheckInterval;
+
+void PySys_ResetWarnOptions(void);
+void PySys_AddWarnOption(char *);
+int PySys_HasWarnOptions(void);
+
+
+}
+# 129 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/intrcheck.h" 1
+
+
+
+
+extern "C" {
+
+
+int PyOS_InterruptOccurred(void);
+void PyOS_InitInterrupts(void);
+void PyOS_AfterFork(void);
+
+
+}
+# 130 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/import.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+long PyImport_GetMagicNumber(void);
+PyObject * PyImport_ExecCodeModule(char *name, PyObject *co);
+PyObject * PyImport_ExecCodeModuleEx(
+ char *name, PyObject *co, char *pathname);
+PyObject * PyImport_GetModuleDict(void);
+PyObject * PyImport_AddModule(const char *name);
+PyObject * PyImport_ImportModule(const char *name);
+PyObject * PyImport_ImportModuleNoBlock(const char *);
+PyObject * PyImport_ImportModuleLevel(char *name,
+ PyObject *globals, PyObject *locals, PyObject *fromlist, int level);
+
+
+
+
+PyObject * PyImport_GetImporter(PyObject *path);
+PyObject * PyImport_Import(PyObject *name);
+PyObject * PyImport_ReloadModule(PyObject *m);
+void PyImport_Cleanup(void);
+int PyImport_ImportFrozenModule(char *);
+
+
+void _PyImport_AcquireLock(void);
+int _PyImport_ReleaseLock(void);
+
+
+
+
+
+struct filedescr * _PyImport_FindModule(
+ const char *, PyObject *, char *, size_t, FILE **, PyObject **);
+int _PyImport_IsScript(struct filedescr *);
+void _PyImport_ReInitLock(void);
+
+PyObject *_PyImport_FindExtension(char *, char *);
+PyObject *_PyImport_FixupExtension(char *, char *);
+
+struct _inittab {
+    char *name;
+    void (*initfunc)(void);
+};
+
+extern PyTypeObject PyNullImporter_Type;
+extern struct _inittab * PyImport_Inittab;
+
+int PyImport_AppendInittab(char *name, void (*initfunc)(void));
+int PyImport_ExtendInittab(struct _inittab *newtab);
+
+struct _frozen {
+    char *name;
+    unsigned char *code;
+    int size;
+};
+
+
+
+
+extern struct _frozen * PyImport_FrozenModules;
+
+
+}
+# 131 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/abstract.h" 1
+
+
+
+extern "C" {
+# 231 "/usr/include/python2.6/abstract.h"
+     int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result);
+# 304 "/usr/include/python2.6/abstract.h"
+     PyObject * PyObject_Call(PyObject *callable_object,
+      PyObject *args, PyObject *kw);
+# 314 "/usr/include/python2.6/abstract.h"
+     PyObject * PyObject_CallObject(PyObject *callable_object,
+                                               PyObject *args);
+# 326 "/usr/include/python2.6/abstract.h"
+     PyObject * PyObject_CallFunction(PyObject *callable_object,
+                                                 char *format, ...);
+# 340 "/usr/include/python2.6/abstract.h"
+     PyObject * PyObject_CallMethod(PyObject *o, char *m,
+                                               char *format, ...);
+# 352 "/usr/include/python2.6/abstract.h"
+     PyObject * _PyObject_CallFunction_SizeT(PyObject *callable,
+        char *format, ...);
+     PyObject * _PyObject_CallMethod_SizeT(PyObject *o,
+             char *name,
+             char *format, ...);
+
+     PyObject * PyObject_CallFunctionObjArgs(PyObject *callable,
+                                                        ...);
+# 370 "/usr/include/python2.6/abstract.h"
+     PyObject * PyObject_CallMethodObjArgs(PyObject *o,
+                                                      PyObject *m, ...);
+# 413 "/usr/include/python2.6/abstract.h"
+     PyObject * PyObject_Type(PyObject *o);
+
+
+
+
+
+
+
+     Py_ssize_t PyObject_Size(PyObject *o);
+# 433 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t PyObject_Length(PyObject *o);
+
+
+     Py_ssize_t _PyObject_LengthHint(PyObject *o, Py_ssize_t);
+
+
+
+
+
+
+
+     PyObject * PyObject_GetItem(PyObject *o, PyObject *key);
+# 453 "/usr/include/python2.6/abstract.h"
+     int PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v);
+
+
+
+
+
+
+
+     int PyObject_DelItemString(PyObject *o, char *key);
+
+
+
+
+
+
+
+     int PyObject_DelItem(PyObject *o, PyObject *key);
+
+
+
+
+
+
+     int PyObject_AsCharBuffer(PyObject *obj,
+       const char **buffer,
+       Py_ssize_t *buffer_len);
+# 492 "/usr/include/python2.6/abstract.h"
+     int PyObject_CheckReadBuffer(PyObject *obj);
+# 501 "/usr/include/python2.6/abstract.h"
+     int PyObject_AsReadBuffer(PyObject *obj,
+       const void **buffer,
+       Py_ssize_t *buffer_len);
+# 517 "/usr/include/python2.6/abstract.h"
+     int PyObject_AsWriteBuffer(PyObject *obj,
+        void **buffer,
+        Py_ssize_t *buffer_len);
+# 542 "/usr/include/python2.6/abstract.h"
+     int PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
+     int flags);
+# 552 "/usr/include/python2.6/abstract.h"
+     void * PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
+
+
+
+
+
+     int PyBuffer_SizeFromFormat(const char *);
+
+
+
+
+
+
+     int PyBuffer_ToContiguous(void *buf, Py_buffer *view,
+            Py_ssize_t len, char fort);
+
+     int PyBuffer_FromContiguous(Py_buffer *view, void *buf,
+              Py_ssize_t len, char fort);
+# 588 "/usr/include/python2.6/abstract.h"
+     int PyObject_CopyData(PyObject *dest, PyObject *src);
+
+
+
+
+     int PyBuffer_IsContiguous(Py_buffer *view, char fort);
+
+
+     void PyBuffer_FillContiguousStrides(int ndims,
+            Py_ssize_t *shape,
+          Py_ssize_t *strides,
+                                             int itemsize,
+               char fort);
+
+
+
+
+
+
+
+     int PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf,
+                       Py_ssize_t len, int readonly,
+           int flags);
+
+
+
+
+
+
+
+     void PyBuffer_Release(Py_buffer *view);
+
+
+
+
+     PyObject * PyObject_Format(PyObject* obj,
+         PyObject *format_spec);
+
+
+
+
+
+
+
+     PyObject * PyObject_GetIter(PyObject *);
+# 641 "/usr/include/python2.6/abstract.h"
+     PyObject * PyIter_Next(PyObject *);
+
+
+
+
+
+
+
+     int PyNumber_Check(PyObject *o);
+# 659 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Add(PyObject *o1, PyObject *o2);
+# 668 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Subtract(PyObject *o1, PyObject *o2);
+# 677 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Multiply(PyObject *o1, PyObject *o2);
+# 687 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Divide(PyObject *o1, PyObject *o2);
+# 696 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_FloorDivide(PyObject *o1, PyObject *o2);
+# 706 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_TrueDivide(PyObject *o1, PyObject *o2);
+# 716 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Remainder(PyObject *o1, PyObject *o2);
+# 726 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Divmod(PyObject *o1, PyObject *o2);
+# 736 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Power(PyObject *o1, PyObject *o2,
+                                          PyObject *o3);
+# 746 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Negative(PyObject *o);
+
+
+
+
+
+
+
+     PyObject * PyNumber_Positive(PyObject *o);
+
+
+
+
+
+
+
+     PyObject * PyNumber_Absolute(PyObject *o);
+
+
+
+
+
+
+
+     PyObject * PyNumber_Invert(PyObject *o);
+# 780 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Lshift(PyObject *o1, PyObject *o2);
+# 790 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Rshift(PyObject *o1, PyObject *o2);
+# 799 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_And(PyObject *o1, PyObject *o2);
+# 809 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Xor(PyObject *o1, PyObject *o2);
+# 819 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Or(PyObject *o1, PyObject *o2);
+# 852 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Index(PyObject *o);
+
+
+
+
+
+
+     Py_ssize_t PyNumber_AsSsize_t(PyObject *o, PyObject *exc);
+# 870 "/usr/include/python2.6/abstract.h"
+     PyObject * _PyNumber_ConvertIntegralToInt(
+             PyObject *integral,
+             const char* error_format);
+# 882 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Int(PyObject *o);
+# 891 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Long(PyObject *o);
+# 900 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_Float(PyObject *o);
+# 910 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceAdd(PyObject *o1, PyObject *o2);
+# 919 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceSubtract(PyObject *o1, PyObject *o2);
+# 928 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceMultiply(PyObject *o1, PyObject *o2);
+# 937 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceDivide(PyObject *o1, PyObject *o2);
+# 946 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceFloorDivide(PyObject *o1,
+             PyObject *o2);
+# 957 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceTrueDivide(PyObject *o1,
+            PyObject *o2);
+# 968 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceRemainder(PyObject *o1, PyObject *o2);
+# 977 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlacePower(PyObject *o1, PyObject *o2,
+            PyObject *o3);
+# 987 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceLshift(PyObject *o1, PyObject *o2);
+# 996 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceRshift(PyObject *o1, PyObject *o2);
+# 1005 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceAnd(PyObject *o1, PyObject *o2);
+# 1014 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceXor(PyObject *o1, PyObject *o2);
+# 1023 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_InPlaceOr(PyObject *o1, PyObject *o2);
+# 1033 "/usr/include/python2.6/abstract.h"
+     PyObject * PyNumber_ToBase(PyObject *n, int base);
+# 1044 "/usr/include/python2.6/abstract.h"
+     int PySequence_Check(PyObject *o);
+# 1054 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t PySequence_Size(PyObject *o);
+# 1063 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t PySequence_Length(PyObject *o);
+
+
+
+     PyObject * PySequence_Concat(PyObject *o1, PyObject *o2);
+# 1076 "/usr/include/python2.6/abstract.h"
+     PyObject * PySequence_Repeat(PyObject *o, Py_ssize_t count);
+# 1085 "/usr/include/python2.6/abstract.h"
+     PyObject * PySequence_GetItem(PyObject *o, Py_ssize_t i);
+
+
+
+
+
+
+     PyObject * PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
+# 1101 "/usr/include/python2.6/abstract.h"
+     int PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v);
+# 1110 "/usr/include/python2.6/abstract.h"
+     int PySequence_DelItem(PyObject *o, Py_ssize_t i);
+
+
+
+
+
+
+
+     int PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2,
+                                        PyObject *v);
+
+
+
+
+
+
+
+     int PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2);
+
+
+
+
+
+
+
+     PyObject * PySequence_Tuple(PyObject *o);
+
+
+
+
+
+
+
+     PyObject * PySequence_List(PyObject *o);
+
+
+
+
+
+     PyObject * PySequence_Fast(PyObject *o, const char* m);
+# 1185 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t PySequence_Count(PyObject *o, PyObject *value);
+# 1194 "/usr/include/python2.6/abstract.h"
+     int PySequence_Contains(PyObject *seq, PyObject *ob);
+# 1203 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t _PySequence_IterSearch(PyObject *seq,
+          PyObject *obj, int operation);
+# 1218 "/usr/include/python2.6/abstract.h"
+     int PySequence_In(PyObject *o, PyObject *value);
+# 1229 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t PySequence_Index(PyObject *o, PyObject *value);
+# 1239 "/usr/include/python2.6/abstract.h"
+     PyObject * PySequence_InPlaceConcat(PyObject *o1, PyObject *o2);
+# 1248 "/usr/include/python2.6/abstract.h"
+     PyObject * PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count);
+# 1259 "/usr/include/python2.6/abstract.h"
+     int PyMapping_Check(PyObject *o);
+# 1268 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t PyMapping_Size(PyObject *o);
+# 1278 "/usr/include/python2.6/abstract.h"
+     Py_ssize_t PyMapping_Length(PyObject *o);
+# 1302 "/usr/include/python2.6/abstract.h"
+     int PyMapping_HasKeyString(PyObject *o, char *key);
+# 1312 "/usr/include/python2.6/abstract.h"
+     int PyMapping_HasKey(PyObject *o, PyObject *key);
+# 1355 "/usr/include/python2.6/abstract.h"
+     PyObject * PyMapping_GetItemString(PyObject *o, char *key);
+
+
+
+
+
+
+
+     int PyMapping_SetItemString(PyObject *o, char *key,
+                                            PyObject *value);
+# 1373 "/usr/include/python2.6/abstract.h"
+int PyObject_IsInstance(PyObject *object, PyObject *typeorclass);
+
+
+int PyObject_IsSubclass(PyObject *object, PyObject *typeorclass);
+
+
+
+int _PyObject_RealIsInstance(PyObject *inst, PyObject *cls);
+
+int _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls);
+
+
+
+}
+# 133 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/compile.h" 1
+
+
+
+
+# 1 "/usr/include/python2.6/code.h" 1
+
+
+
+
+
+extern "C" {
+
+
+
+typedef struct {
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+    int co_argcount;
+    int co_nlocals;
+    int co_stacksize;
+    int co_flags;
+    PyObject *co_code;
+    PyObject *co_consts;
+    PyObject *co_names;
+    PyObject *co_varnames;
+    PyObject *co_freevars;
+    PyObject *co_cellvars;
+
+    PyObject *co_filename;
+    PyObject *co_name;
+    int co_firstlineno;
+    PyObject *co_lnotab;
+    void *co_zombieframe;
+} PyCodeObject;
+# 63 "/usr/include/python2.6/code.h"
+extern PyTypeObject PyCode_Type;
+
+
+
+
+
+PyCodeObject * PyCode_New(
+ int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *,
+ PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *);
+
+int PyCode_Addr2Line(PyCodeObject *, int);
+
+
+
+
+
+
+typedef struct _addr_pair {
+        int ap_lower;
+        int ap_upper;
+} PyAddrPair;
+# 92 "/usr/include/python2.6/code.h"
+int PyCode_CheckLineNumber(PyCodeObject* co,
+                                       int lasti, PyAddrPair *bounds);
+
+PyObject* PyCode_Optimize(PyObject *code, PyObject* consts,
+                                      PyObject *names, PyObject *lineno_obj);
+
+
+}
+# 6 "/usr/include/python2.6/compile.h" 2
+
+
+extern "C" {
+
+
+
+struct _node;
+PyCodeObject * PyNode_Compile(struct _node *, const char *);
+
+
+
+typedef struct {
+    int ff_features;
+    int ff_lineno;
+} PyFutureFeatures;
+# 31 "/usr/include/python2.6/compile.h"
+struct _mod;
+PyCodeObject * PyAST_Compile(struct _mod *, const char *,
+     PyCompilerFlags *, PyArena *);
+PyFutureFeatures * PyFuture_FromAST(struct _mod *, const char *);
+
+
+
+
+
+}
+# 135 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/eval.h" 1
+
+
+
+
+
+
+extern "C" {
+
+
+PyObject * PyEval_EvalCode(PyCodeObject *, PyObject *, PyObject *);
+
+PyObject * PyEval_EvalCodeEx(PyCodeObject *co,
+     PyObject *globals,
+     PyObject *locals,
+     PyObject **args, int argc,
+     PyObject **kwds, int kwdc,
+     PyObject **defs, int defc,
+     PyObject *closure);
+
+PyObject * _PyEval_CallTracing(PyObject *func, PyObject *args);
+
+
+}
+# 136 "/usr/include/python2.6/Python.h" 2
+
+# 1 "/usr/include/python2.6/pystrtod.h" 1
+
+
+
+
+extern "C" {
+
+
+
+double PyOS_ascii_strtod(const char *str, char **ptr);
+double PyOS_ascii_atof(const char *str);
+char * PyOS_ascii_formatd(char *buffer, size_t buf_len, const char *format, double d);
+
+
+
+}
+# 138 "/usr/include/python2.6/Python.h" 2
+# 1 "/usr/include/python2.6/pystrcmp.h" 1
+
+
+
+
+extern "C" {
+
+
+int PyOS_mystrnicmp(const char *, const char *, Py_ssize_t);
+int PyOS_mystricmp(const char *, const char *);
+# 20 "/usr/include/python2.6/pystrcmp.h"
+}
+# 139 "/usr/include/python2.6/Python.h" 2
+
+
+PyObject* _Py_Mangle(PyObject *p, PyObject *name);
+# 158 "/usr/include/python2.6/Python.h"
+# 1 "/usr/include/python2.6/pyfpe.h" 1
+
+
+
+extern "C" {
+# 129 "/usr/include/python2.6/pyfpe.h"
+# 1 "/usr/include/signal.h" 1 3 4
+# 31 "/usr/include/signal.h" 3 4
+extern "C" {
+
+# 1 "/usr/include/bits/sigset.h" 1 3 4
+# 104 "/usr/include/bits/sigset.h" 3 4
+extern int __sigismember (__const __sigset_t *, int);
+extern int __sigaddset (__sigset_t *, int);
+extern int __sigdelset (__sigset_t *, int);
+# 118 "/usr/include/bits/sigset.h" 3 4
+extern __inline __attribute__ ((__gnu_inline__)) int __sigismember (__const __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return (__set->__val[__word] & __mask) ? 1 : 0; }
+extern __inline __attribute__ ((__gnu_inline__)) int __sigaddset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] |= __mask), 0); }
+extern __inline __attribute__ ((__gnu_inline__)) int __sigdelset ( __sigset_t *__set, int __sig) { unsigned long int __mask = (((unsigned long int) 1) << (((__sig) - 1) % (8 * sizeof (unsigned long int)))); unsigned long int __word = (((__sig) - 1) / (8 * sizeof (unsigned long int))); return ((__set->__val[__word] &= ~__mask), 0); }
+# 34 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+
+
+typedef __sig_atomic_t sig_atomic_t;
+
+# 58 "/usr/include/signal.h" 3 4
+# 1 "/usr/include/bits/signum.h" 1 3 4
+# 59 "/usr/include/signal.h" 2 3 4
+# 79 "/usr/include/signal.h" 3 4
+# 1 "/usr/include/bits/siginfo.h" 1 3 4
+# 25 "/usr/include/bits/siginfo.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 26 "/usr/include/bits/siginfo.h" 2 3 4
+
+
+
+
+
+
+
+typedef union sigval
+  {
+    int sival_int;
+    void *sival_ptr;
+  } sigval_t;
+# 51 "/usr/include/bits/siginfo.h" 3 4
+typedef struct siginfo
+  {
+    int si_signo;
+    int si_errno;
+
+    int si_code;
+
+    union
+      {
+ int _pad[((128 / sizeof (int)) - 4)];
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+   } _kill;
+
+
+ struct
+   {
+     int si_tid;
+     int si_overrun;
+     sigval_t si_sigval;
+   } _timer;
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+     sigval_t si_sigval;
+   } _rt;
+
+
+ struct
+   {
+     __pid_t si_pid;
+     __uid_t si_uid;
+     int si_status;
+     __clock_t si_utime;
+     __clock_t si_stime;
+   } _sigchld;
+
+
+ struct
+   {
+     void *si_addr;
+   } _sigfault;
+
+
+ struct
+   {
+     long int si_band;
+     int si_fd;
+   } _sigpoll;
+      } _sifields;
+  } siginfo_t;
+# 129 "/usr/include/bits/siginfo.h" 3 4
+enum
+{
+  SI_ASYNCNL = -60,
+
+  SI_TKILL = -6,
+
+  SI_SIGIO,
+
+  SI_ASYNCIO,
+
+  SI_MESGQ,
+
+  SI_TIMER,
+
+  SI_QUEUE,
+
+  SI_USER,
+
+  SI_KERNEL = 0x80
+
+};
+
+
+
+enum
+{
+  ILL_ILLOPC = 1,
+
+  ILL_ILLOPN,
+
+  ILL_ILLADR,
+
+  ILL_ILLTRP,
+
+  ILL_PRVOPC,
+
+  ILL_PRVREG,
+
+  ILL_COPROC,
+
+  ILL_BADSTK
+
+};
+
+
+enum
+{
+  FPE_INTDIV = 1,
+
+  FPE_INTOVF,
+
+  FPE_FLTDIV,
+
+  FPE_FLTOVF,
+
+  FPE_FLTUND,
+
+  FPE_FLTRES,
+
+  FPE_FLTINV,
+
+  FPE_FLTSUB
+
+};
+
+
+enum
+{
+  SEGV_MAPERR = 1,
+
+  SEGV_ACCERR
+
+};
+
+
+enum
+{
+  BUS_ADRALN = 1,
+
+  BUS_ADRERR,
+
+  BUS_OBJERR
+
+};
+
+
+enum
+{
+  TRAP_BRKPT = 1,
+
+  TRAP_TRACE
+
+};
+
+
+enum
+{
+  CLD_EXITED = 1,
+
+  CLD_KILLED,
+
+  CLD_DUMPED,
+
+  CLD_TRAPPED,
+
+  CLD_STOPPED,
+
+  CLD_CONTINUED
+
+};
+
+
+enum
+{
+  POLL_IN = 1,
+
+  POLL_OUT,
+
+  POLL_MSG,
+
+  POLL_ERR,
+
+  POLL_PRI,
+
+  POLL_HUP
+
+};
+# 273 "/usr/include/bits/siginfo.h" 3 4
+typedef struct sigevent
+  {
+    sigval_t sigev_value;
+    int sigev_signo;
+    int sigev_notify;
+
+    union
+      {
+ int _pad[((64 / sizeof (int)) - 4)];
+
+
+
+ __pid_t _tid;
+
+ struct
+   {
+     void (*_function) (sigval_t);
+     void *_attribute;
+   } _sigev_thread;
+      } _sigev_un;
+  } sigevent_t;
+
+
+
+
+
+
+enum
+{
+  SIGEV_SIGNAL = 0,
+
+  SIGEV_NONE,
+
+  SIGEV_THREAD,
+
+
+  SIGEV_THREAD_ID = 4
+
+};
+# 80 "/usr/include/signal.h" 2 3 4
+
+
+
+
+typedef void (*__sighandler_t) (int);
+
+
+
+
+extern __sighandler_t __sysv_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+
+
+
+
+
+
+extern __sighandler_t signal (int __sig, __sighandler_t __handler)
+     throw ();
+# 113 "/usr/include/signal.h" 3 4
+
+
+
+
+
+extern __sighandler_t bsd_signal (int __sig, __sighandler_t __handler)
+     throw ();
+
+
+
+
+
+
+extern int kill (__pid_t __pid, int __sig) throw ();
+
+
+
+
+
+
+extern int killpg (__pid_t __pgrp, int __sig) throw ();
+
+
+
+
+extern int raise (int __sig) throw ();
+
+
+
+
+extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
+     throw ();
+extern int gsignal (int __sig) throw ();
+
+
+
+
+extern void psignal (int __sig, __const char *__s);
+
+
+
+
+extern void psiginfo (__const siginfo_t *__pinfo, __const char *__s);
+# 168 "/usr/include/signal.h" 3 4
+extern int __sigpause (int __sig_or_mask, int __is_sig);
+# 177 "/usr/include/signal.h" 3 4
+extern int sigpause (int __sig) __asm__ ("__xpg_sigpause");
+# 196 "/usr/include/signal.h" 3 4
+extern int sigblock (int __mask) throw () __attribute__ ((__deprecated__));
+
+
+extern int sigsetmask (int __mask) throw () __attribute__ ((__deprecated__));
+
+
+extern int siggetmask (void) throw () __attribute__ ((__deprecated__));
+# 211 "/usr/include/signal.h" 3 4
+typedef __sighandler_t sighandler_t;
+
+
+
+
+typedef __sighandler_t sig_t;
+
+
+
+
+
+extern int sigemptyset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigfillset (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigaddset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigdelset (sigset_t *__set, int __signo) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigismember (__const sigset_t *__set, int __signo)
+     throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int sigisemptyset (__const sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigandset (sigset_t *__set, __const sigset_t *__left,
+        __const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+extern int sigorset (sigset_t *__set, __const sigset_t *__left,
+       __const sigset_t *__right) throw () __attribute__ ((__nonnull__ (1, 2, 3)));
+
+
+
+
+# 1 "/usr/include/bits/sigaction.h" 1 3 4
+# 25 "/usr/include/bits/sigaction.h" 3 4
+struct sigaction
+  {
+
+
+    union
+      {
+
+ __sighandler_t sa_handler;
+
+ void (*sa_sigaction) (int, siginfo_t *, void *);
+      }
+    __sigaction_handler;
+
+
+
+
+
+
+
+    __sigset_t sa_mask;
+
+
+    int sa_flags;
+
+
+    void (*sa_restorer) (void);
+  };
+# 253 "/usr/include/signal.h" 2 3 4
+
+
+extern int sigprocmask (int __how, __const sigset_t *__restrict __set,
+   sigset_t *__restrict __oset) throw ();
+
+
+
+
+
+
+extern int sigsuspend (__const sigset_t *__set) __attribute__ ((__nonnull__ (1)));
+
+
+extern int sigaction (int __sig, __const struct sigaction *__restrict __act,
+        struct sigaction *__restrict __oact) throw ();
+
+
+extern int sigpending (sigset_t *__set) throw () __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int sigwait (__const sigset_t *__restrict __set, int *__restrict __sig)
+     __attribute__ ((__nonnull__ (1, 2)));
+
+
+
+
+
+
+extern int sigwaitinfo (__const sigset_t *__restrict __set,
+   siginfo_t *__restrict __info) __attribute__ ((__nonnull__ (1)));
+
+
+
+
+
+
+extern int sigtimedwait (__const sigset_t *__restrict __set,
+    siginfo_t *__restrict __info,
+    __const struct timespec *__restrict __timeout)
+     __attribute__ ((__nonnull__ (1)));
+
+
+
+extern int sigqueue (__pid_t __pid, int __sig, __const union sigval __val)
+     throw ();
+# 310 "/usr/include/signal.h" 3 4
+extern __const char *__const _sys_siglist[65];
+extern __const char *__const sys_siglist[65];
+
+
+struct sigvec
+  {
+    __sighandler_t sv_handler;
+    int sv_mask;
+
+    int sv_flags;
+
+  };
+# 334 "/usr/include/signal.h" 3 4
+extern int sigvec (int __sig, __const struct sigvec *__vec,
+     struct sigvec *__ovec) throw ();
+
+
+
+# 1 "/usr/include/bits/sigcontext.h" 1 3 4
+# 26 "/usr/include/bits/sigcontext.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 27 "/usr/include/bits/sigcontext.h" 2 3 4
+
+struct _fpreg
+{
+  unsigned short significand[4];
+  unsigned short exponent;
+};
+
+struct _fpxreg
+{
+  unsigned short significand[4];
+  unsigned short exponent;
+  unsigned short padding[3];
+};
+
+struct _xmmreg
+{
+  __uint32_t element[4];
+};
+# 109 "/usr/include/bits/sigcontext.h" 3 4
+struct _fpstate
+{
+
+  __uint16_t cwd;
+  __uint16_t swd;
+  __uint16_t ftw;
+  __uint16_t fop;
+  __uint64_t rip;
+  __uint64_t rdp;
+  __uint32_t mxcsr;
+  __uint32_t mxcr_mask;
+  struct _fpxreg _st[8];
+  struct _xmmreg _xmm[16];
+  __uint32_t padding[24];
+};
+
+struct sigcontext
+{
+  unsigned long r8;
+  unsigned long r9;
+  unsigned long r10;
+  unsigned long r11;
+  unsigned long r12;
+  unsigned long r13;
+  unsigned long r14;
+  unsigned long r15;
+  unsigned long rdi;
+  unsigned long rsi;
+  unsigned long rbp;
+  unsigned long rbx;
+  unsigned long rdx;
+  unsigned long rax;
+  unsigned long rcx;
+  unsigned long rsp;
+  unsigned long rip;
+  unsigned long eflags;
+  unsigned short cs;
+  unsigned short gs;
+  unsigned short fs;
+  unsigned short __pad0;
+  unsigned long err;
+  unsigned long trapno;
+  unsigned long oldmask;
+  unsigned long cr2;
+  struct _fpstate * fpstate;
+  unsigned long __reserved1 [8];
+};
+# 340 "/usr/include/signal.h" 2 3 4
+
+
+extern int sigreturn (struct sigcontext *__scp) throw ();
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 350 "/usr/include/signal.h" 2 3 4
+
+
+
+
+extern int siginterrupt (int __sig, int __interrupt) throw ();
+
+# 1 "/usr/include/bits/sigstack.h" 1 3 4
+# 26 "/usr/include/bits/sigstack.h" 3 4
+struct sigstack
+  {
+    void *ss_sp;
+    int ss_onstack;
+  };
+
+
+
+enum
+{
+  SS_ONSTACK = 1,
+
+  SS_DISABLE
+
+};
+# 50 "/usr/include/bits/sigstack.h" 3 4
+typedef struct sigaltstack
+  {
+    void *ss_sp;
+    int ss_flags;
+    size_t ss_size;
+  } stack_t;
+# 357 "/usr/include/signal.h" 2 3 4
+
+
+# 1 "/usr/include/sys/ucontext.h" 1 3 4
+# 24 "/usr/include/sys/ucontext.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 25 "/usr/include/sys/ucontext.h" 2 3 4
+# 33 "/usr/include/sys/ucontext.h" 3 4
+typedef long int greg_t;
+
+
+
+
+
+typedef greg_t gregset_t[23];
+
+
+
+enum
+{
+  REG_R8 = 0,
+
+  REG_R9,
+
+  REG_R10,
+
+  REG_R11,
+
+  REG_R12,
+
+  REG_R13,
+
+  REG_R14,
+
+  REG_R15,
+
+  REG_RDI,
+
+  REG_RSI,
+
+  REG_RBP,
+
+  REG_RBX,
+
+  REG_RDX,
+
+  REG_RAX,
+
+  REG_RCX,
+
+  REG_RSP,
+
+  REG_RIP,
+
+  REG_EFL,
+
+  REG_CSGSFS,
+
+  REG_ERR,
+
+  REG_TRAPNO,
+
+  REG_OLDMASK,
+
+  REG_CR2
+
+};
+
+
+struct _libc_fpxreg
+{
+  unsigned short int significand[4];
+  unsigned short int exponent;
+  unsigned short int padding[3];
+};
+
+struct _libc_xmmreg
+{
+  __uint32_t element[4];
+};
+
+struct _libc_fpstate
+{
+
+  __uint16_t cwd;
+  __uint16_t swd;
+  __uint16_t ftw;
+  __uint16_t fop;
+  __uint64_t rip;
+  __uint64_t rdp;
+  __uint32_t mxcsr;
+  __uint32_t mxcr_mask;
+  struct _libc_fpxreg _st[8];
+  struct _libc_xmmreg _xmm[16];
+  __uint32_t padding[24];
+};
+
+
+typedef struct _libc_fpstate *fpregset_t;
+
+
+typedef struct
+  {
+    gregset_t gregs;
+
+    fpregset_t fpregs;
+    unsigned long __reserved1 [8];
+} mcontext_t;
+
+
+typedef struct ucontext
+  {
+    unsigned long int uc_flags;
+    struct ucontext *uc_link;
+    stack_t uc_stack;
+    mcontext_t uc_mcontext;
+    __sigset_t uc_sigmask;
+    struct _libc_fpstate __fpregs_mem;
+  } ucontext_t;
+# 360 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
+     throw () __attribute__ ((__deprecated__));
+
+
+
+extern int sigaltstack (__const struct sigaltstack *__restrict __ss,
+   struct sigaltstack *__restrict __oss) throw ();
+
+
+
+
+
+
+
+extern int sighold (int __sig) throw ();
+
+
+extern int sigrelse (int __sig) throw ();
+
+
+extern int sigignore (int __sig) throw ();
+
+
+extern __sighandler_t sigset (int __sig, __sighandler_t __disp) throw ();
+
+
+
+
+
+
+# 1 "/usr/include/bits/sigthread.h" 1 3 4
+# 31 "/usr/include/bits/sigthread.h" 3 4
+extern int pthread_sigmask (int __how,
+       __const __sigset_t *__restrict __newmask,
+       __sigset_t *__restrict __oldmask)throw ();
+
+
+extern int pthread_kill (pthread_t __threadid, int __signo) throw ();
+
+
+
+extern int pthread_sigqueue (pthread_t __threadid, int __signo,
+        const union sigval __value) throw ();
+# 396 "/usr/include/signal.h" 2 3 4
+
+
+
+
+
+
+extern int __libc_current_sigrtmin (void) throw ();
+
+extern int __libc_current_sigrtmax (void) throw ();
+
+
+
+}
+# 130 "/usr/include/python2.6/pyfpe.h" 2
+# 1 "/usr/include/setjmp.h" 1 3 4
+# 28 "/usr/include/setjmp.h" 3 4
+extern "C" {
+
+
+# 1 "/usr/include/bits/sigset.h" 1 3 4
+# 32 "/usr/include/setjmp.h" 2 3 4
+
+
+
+struct __jmp_buf_tag
+  {
+
+
+
+
+    __jmp_buf __jmpbuf;
+    int __mask_was_saved;
+    __sigset_t __saved_mask;
+  };
+
+
+
+
+typedef struct __jmp_buf_tag jmp_buf[1];
+
+
+
+extern int setjmp (jmp_buf __env) throw ();
+
+
+
+
+
+
+extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) throw ();
+
+
+
+
+extern int _setjmp (struct __jmp_buf_tag __env[1]) throw ();
+# 78 "/usr/include/setjmp.h" 3 4
+
+
+
+
+extern void longjmp (struct __jmp_buf_tag __env[1], int __val)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+extern void _longjmp (struct __jmp_buf_tag __env[1], int __val)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+
+
+typedef struct __jmp_buf_tag sigjmp_buf[1];
+# 110 "/usr/include/setjmp.h" 3 4
+extern void siglongjmp (sigjmp_buf __env, int __val)
+     throw () __attribute__ ((__noreturn__));
+
+
+
+
+
+# 1 "/usr/include/bits/setjmp2.h" 1 3 4
+# 26 "/usr/include/bits/setjmp2.h" 3 4
+extern void longjmp (struct __jmp_buf_tag __env[1], int __val) throw () __asm__ ("" "__longjmp_chk")
+
+                      __attribute__ ((__noreturn__));
+extern void _longjmp (struct __jmp_buf_tag __env[1], int __val) throw () __asm__ ("" "__longjmp_chk")
+
+                      __attribute__ ((__noreturn__));
+extern void siglongjmp (struct __jmp_buf_tag __env[1], int __val) throw () __asm__ ("" "__longjmp_chk")
+
+                      __attribute__ ((__noreturn__));
+# 118 "/usr/include/setjmp.h" 2 3 4
+
+
+}
+# 131 "/usr/include/python2.6/pyfpe.h" 2
+
+extern jmp_buf PyFPE_jbuf;
+extern int PyFPE_counter;
+extern double PyFPE_dummy(void *);
+# 174 "/usr/include/python2.6/pyfpe.h"
+}
+# 159 "/usr/include/python2.6/Python.h" 2
+# 143 "/usr/include/boost-1_42/boost/python/detail/wrap_python.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/detail/config.hpp"
+# 1 "/usr/include/boost-1_42/boost/config.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/config.hpp"
+# 1 "/usr/include/boost-1_42/boost/config/user.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/config.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/config/select_compiler_config.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/config.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/config/compiler/gcc.hpp" 1
+# 36 "/usr/include/boost-1_42/boost/config.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 18 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp"
+# 1 "/usr/include/boost-1_42/boost/config/no_tr1/utility.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/config/no_tr1/utility.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 1 3
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 3
+       
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 3
+# 70 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 1 3
+# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  namespace rel_ops
+  {
+# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator!=(const _Tp& __x, const _Tp& __y)
+      { return !(__x == __y); }
+# 96 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>(const _Tp& __x, const _Tp& __y)
+      { return __y < __x; }
+# 109 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator<=(const _Tp& __x, const _Tp& __y)
+      { return !(__y < __x); }
+# 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_relops.h" 3
+    template <class _Tp>
+      inline bool
+      operator>=(const _Tp& __x, const _Tp& __y)
+      { return !(__x < __y); }
+
+  }
+
+}
+# 71 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/utility" 2 3
+# 22 "/usr/include/boost-1_42/boost/config/no_tr1/utility.hpp" 2
+# 34 "/usr/include/boost-1_42/boost/config/select_stdlib_config.hpp" 2
+# 41 "/usr/include/boost-1_42/boost/config.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/config/stdlib/libstdcpp3.hpp" 1
+# 45 "/usr/include/boost-1_42/boost/config.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/config/select_platform_config.hpp" 1
+# 50 "/usr/include/boost-1_42/boost/config.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/config/platform/linux.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/config/platform/linux.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 2 3
+# 100 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::div_t;
+  using ::ldiv_t;
+
+  using ::abort;
+  using ::abs;
+  using ::atexit;
+  using ::atof;
+  using ::atoi;
+  using ::atol;
+  using ::bsearch;
+  using ::calloc;
+  using ::div;
+  using ::exit;
+  using ::free;
+  using ::getenv;
+  using ::labs;
+  using ::ldiv;
+  using ::malloc;
+
+  using ::mblen;
+  using ::mbstowcs;
+  using ::mbtowc;
+
+  using ::qsort;
+  using ::rand;
+  using ::realloc;
+  using ::srand;
+  using ::strtod;
+  using ::strtol;
+  using ::strtoul;
+  using ::system;
+
+  using ::wcstombs;
+  using ::wctomb;
+
+
+  inline long
+  abs(long __i) { return labs(__i); }
+
+  inline ldiv_t
+  div(long __i, long __j) { return ldiv(__i, __j); }
+
+}
+# 157 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+
+  using ::lldiv_t;
+
+
+
+
+
+  using ::_Exit;
+
+
+  inline long long
+  abs(long long __x) { return __x >= 0 ? __x : -__x; }
+
+
+  using ::llabs;
+
+  inline lldiv_t
+  div(long long __n, long long __d)
+  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }
+
+  using ::lldiv;
+# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
+  using ::atoll;
+  using ::strtoll;
+  using ::strtoull;
+
+  using ::strtof;
+  using ::strtold;
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  using ::__gnu_cxx::lldiv_t;
+
+  using ::__gnu_cxx::_Exit;
+  using ::__gnu_cxx::abs;
+
+  using ::__gnu_cxx::llabs;
+  using ::__gnu_cxx::div;
+  using ::__gnu_cxx::lldiv;
+
+  using ::__gnu_cxx::atoll;
+  using ::__gnu_cxx::strtof;
+  using ::__gnu_cxx::strtoll;
+  using ::__gnu_cxx::strtoull;
+  using ::__gnu_cxx::strtold;
+
+}
+# 15 "/usr/include/boost-1_42/boost/config/platform/linux.hpp" 2
+# 70 "/usr/include/boost-1_42/boost/config/platform/linux.hpp"
+# 1 "/usr/include/boost-1_42/boost/config/posix_features.hpp" 1
+# 71 "/usr/include/boost-1_42/boost/config/platform/linux.hpp" 2
+# 54 "/usr/include/boost-1_42/boost/config.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/config/suffix.hpp" 1
+# 468 "/usr/include/boost-1_42/boost/config/suffix.hpp"
+namespace boost{
+
+   __extension__ typedef long long long_long_type;
+   __extension__ typedef unsigned long long ulong_long_type;
+
+
+
+
+}
+# 58 "/usr/include/boost-1_42/boost/config.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/detail/workaround.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 2
+# 134 "/usr/include/boost-1_42/boost/python/detail/config.hpp"
+# 1 "/usr/include/boost-1_42/boost/config/auto_link.hpp" 1
+# 135 "/usr/include/boost-1_42/boost/python/detail/config.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/python/detail/prefix.hpp" 2
+# 9 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/args_fwd.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/args_fwd.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/handle.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/handle.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/cast.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/cast.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/same_traits.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/same_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/config.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/int.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/int.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/msvc.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/intel.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/gcc.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/workaround.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/aux_/config/adl.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/mpl/aux_/adl_barrier.hpp"
+namespace mpl_ { namespace aux {} }
+namespace boost { namespace mpl { using namespace mpl_;
+namespace aux { using namespace mpl_::aux; }
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/nttp_decl.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/nttp_decl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/nttp.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/nttp_decl.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/mpl/int_fwd.hpp" 2
+
+namespace mpl_ {
+
+template< int N > struct int_;
+
+}
+namespace boost { namespace mpl { using ::mpl_::int_; } }
+# 18 "/usr/include/boost-1_42/boost/mpl/int.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/integral_c_tag.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/integral_c_tag.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/static_constant.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/integral_c_tag.hpp" 2
+
+namespace mpl_ {
+struct integral_c_tag { static const int value = 0; };
+}
+namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/static_cast.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/cat.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/cat.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/config/config.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/cat.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 2
+# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+namespace mpl_ {
+
+template< int N >
+struct int_
+{
+    static const int value = N;
+
+
+
+
+
+    typedef int_ type;
+
+    typedef int value_type;
+    typedef integral_c_tag tag;
+# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+    typedef mpl_::int_< static_cast<int>((value + 1)) > next;
+    typedef mpl_::int_< static_cast<int>((value - 1)) > prior;
+
+
+
+
+
+
+    operator int() const { return static_cast<int>(this->value); }
+};
+
+
+template< int N >
+int const mpl_::int_< N >::value;
+
+
+}
+# 21 "/usr/include/boost-1_42/boost/mpl/int.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity_fwd.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< typename F > struct template_arity;
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/preprocessor.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/comma_if.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/comma_if.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/control/iif.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/bool.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/control/if.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/facilities/empty.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/preprocessor/punctuation/comma_if.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/preprocessor/comma_if.hpp" 2
+# 46 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repeat.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/repeat.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/debug/error.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/eat.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/preprocessor/repeat.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/inc.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/inc.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/inc.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/inc.hpp" 2
+# 48 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/params.hpp" 2
+# 13 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/ttp.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/ctps.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/config/lambda.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/overload_resolution.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/bool.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/bool.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/bool_fwd.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/bool_fwd.hpp"
+namespace mpl_ {
+
+template< bool C_ > struct bool_;
+
+
+typedef bool_<true> true_;
+typedef bool_<false> false_;
+
+}
+
+namespace boost { namespace mpl { using ::mpl_::bool_; } }
+namespace boost { namespace mpl { using ::mpl_::true_; } }
+namespace boost { namespace mpl { using ::mpl_::false_; } }
+# 18 "/usr/include/boost-1_42/boost/mpl/bool.hpp" 2
+
+
+
+namespace mpl_ {
+
+template< bool C_ > struct bool_
+{
+    static const bool value = C_;
+    typedef integral_c_tag tag;
+    typedef bool_ type;
+    typedef bool value_type;
+    operator bool() const { return this->value; }
+};
+
+
+template< bool C_ >
+bool const bool_<C_>::value;
+
+
+}
+# 11 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/integral_c_fwd.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/integral_c_fwd.hpp"
+namespace mpl_ {
+
+
+
+
+
+template< typename T, T N > struct integral_c;
+
+
+}
+namespace boost { namespace mpl { using ::mpl_::integral_c; } }
+# 18 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
+# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+namespace mpl_ {
+
+template< typename T, T N >
+struct integral_c
+{
+    static const T value = N;
+
+
+
+
+
+    typedef integral_c type;
+
+    typedef T value_type;
+    typedef integral_c_tag tag;
+# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+    typedef integral_c< T, static_cast<T>((value + 1)) > next;
+    typedef integral_c< T, static_cast<T>((value - 1)) > prior;
+
+
+
+
+
+
+    operator T() const { return static_cast<T>(this->value); }
+};
+
+
+template< typename T, T N >
+T const integral_c< T, N >::value;
+
+
+}
+# 33 "/usr/include/boost-1_42/boost/mpl/integral_c.hpp" 2
+
+
+
+
+namespace mpl_ {
+
+template< bool C >
+struct integral_c<bool, C>
+{
+    static const bool value = C;
+    typedef integral_c_tag tag;
+    typedef integral_c type;
+    typedef bool value_type;
+    operator bool() const { return this->value; }
+};
+}
+# 12 "/usr/include/boost-1_42/boost/type_traits/integral_constant.hpp" 2
+
+namespace boost{
+
+
+
+
+template <class T, T val>
+
+struct integral_constant : public mpl::integral_c<T, val>
+{
+   typedef integral_constant<T,val> type;
+};
+
+template<> struct integral_constant<bool,true> : public mpl::true_
+{
+
+
+
+
+
+
+
+   typedef integral_constant<bool,true> type;
+};
+template<> struct integral_constant<bool,false> : public mpl::false_
+{
+
+
+
+
+
+
+
+   typedef integral_constant<bool,false> type;
+};
+
+typedef integral_constant<bool,true> true_type;
+typedef integral_constant<bool,false> false_type;
+
+}
+# 16 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/lambda_support.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 2
+
+namespace boost {
+
+
+
+template< typename T, typename U > struct is_same : ::boost::integral_constant<bool,false> { };
+template< typename T > struct is_same< T,T > : ::boost::integral_constant<bool,true> { };
+# 98 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 101 "/usr/include/boost-1_42/boost/type_traits/is_same.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/same_traits.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp" 2
+
+namespace boost {
+# 33 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp"
+template< typename T > struct add_const { typedef T const type; };
+
+
+
+
+
+
+template< typename T > struct add_const<T&> { typedef T& type; };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/type_traits/add_const.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp" 2
+
+namespace boost {
+# 33 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp"
+template< typename T > struct add_volatile { typedef T volatile type; };
+
+
+
+
+
+
+template< typename T > struct add_volatile<T&> { typedef T& type; };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/type_traits/add_volatile.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp" 2
+
+namespace boost {
+# 34 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp"
+template< typename T > struct add_cv { typedef T const volatile type; };
+
+
+
+
+
+
+template< typename T > struct add_cv<T&> { typedef T& type; };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/type_traits/add_cv.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/cv_traits_impl.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/type_traits/detail/cv_traits_impl.hpp"
+namespace boost {
+namespace detail {
+
+
+
+
+
+
+
+template <typename T> struct cv_traits_imp {};
+
+template <typename T>
+struct cv_traits_imp<T*>
+{
+    static const bool is_const = false;
+    static const bool is_volatile = false;
+    typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<const T*>
+{
+    static const bool is_const = true;
+    static const bool is_volatile = false;
+    typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<volatile T*>
+{
+    static const bool is_const = false;
+    static const bool is_volatile = true;
+    typedef T unqualified_type;
+};
+
+template <typename T>
+struct cv_traits_imp<const volatile T*>
+{
+    static const bool is_const = true;
+    static const bool is_volatile = true;
+    typedef T unqualified_type;
+};
+# 92 "/usr/include/boost-1_42/boost/type_traits/detail/cv_traits_impl.hpp"
+}
+}
+# 29 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp" 2
+
+namespace boost {
+
+
+
+
+
+template< typename T > struct is_reference : ::boost::integral_constant<bool,false> { };
+template< typename T > struct is_reference< T& > : ::boost::integral_constant<bool,true> { };
+# 113 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 116 "/usr/include/boost-1_42/boost/type_traits/is_reference.hpp" 2
+# 31 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 44 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2
+
+namespace boost {
+# 57 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
+   template< typename T > struct is_const : ::boost::integral_constant<bool,::boost::detail::cv_traits_imp<T*>::is_const> { };
+
+template< typename T > struct is_const< T& > : ::boost::integral_constant<bool,false> { };
+# 141 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 144 "/usr/include/boost-1_42/boost/type_traits/is_const.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp" 1
+# 40 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 41 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp" 2
+
+namespace boost {
+# 52 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp"
+   template< typename T > struct is_volatile : ::boost::integral_constant<bool,::boost::detail::cv_traits_imp<T*>::is_volatile> { };
+
+template< typename T > struct is_volatile< T& > : ::boost::integral_constant<bool,false> { };
+# 129 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 132 "/usr/include/boost-1_42/boost/type_traits/is_volatile.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/broken_compiler_spec.hpp" 1
+# 95 "/usr/include/boost-1_42/boost/type_traits/broken_compiler_spec.hpp"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# 16 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 21 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2
+
+namespace boost {
+
+
+
+namespace detail {
+
+template <typename T, bool is_vol>
+struct remove_const_helper
+{
+    typedef T type;
+};
+
+template <typename T>
+struct remove_const_helper<T, true>
+{
+    typedef T volatile type;
+};
+
+
+template <typename T>
+struct remove_const_impl
+{
+    typedef typename remove_const_helper<
+          typename cv_traits_imp<T*>::unqualified_type
+        , ::boost::is_volatile<T>::value
+        >::type type;
+};
+
+}
+
+
+
+template< typename T > struct remove_const { typedef typename boost::detail::remove_const_impl<T>::type type; };
+template< typename T > struct remove_const<T&> { typedef T& type; };
+
+template< typename T, std::size_t N > struct remove_const<T const[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_const<T const volatile[N]> { typedef T volatile type[N]; };
+# 74 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 77 "/usr/include/boost-1_42/boost/type_traits/remove_const.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 21 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 2
+
+namespace boost {
+
+
+
+namespace detail {
+
+template <typename T, bool is_const>
+struct remove_volatile_helper
+{
+    typedef T type;
+};
+
+template <typename T>
+struct remove_volatile_helper<T,true>
+{
+    typedef T const type;
+};
+
+template <typename T>
+struct remove_volatile_impl
+{
+    typedef typename remove_volatile_helper<
+          typename cv_traits_imp<T*>::unqualified_type
+        , ::boost::is_const<T>::value
+        >::type type;
+};
+
+}
+
+
+
+template< typename T > struct remove_volatile { typedef typename boost::detail::remove_volatile_impl<T>::type type; };
+template< typename T > struct remove_volatile<T&> { typedef T& type; };
+
+template< typename T, std::size_t N > struct remove_volatile<T volatile[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_volatile<T const volatile[N]> { typedef T const type[N]; };
+# 73 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 76 "/usr/include/boost-1_42/boost/type_traits/remove_volatile.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 20 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 2
+
+namespace boost {
+
+
+
+
+template< typename T > struct remove_cv { typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type; };
+template< typename T > struct remove_cv<T&> { typedef T& type; };
+
+template< typename T, std::size_t N > struct remove_cv<T const[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_cv<T volatile[N]> { typedef T type[N]; };
+template< typename T, std::size_t N > struct remove_cv<T const volatile[N]> { typedef T type[N]; };
+# 57 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 60 "/usr/include/boost-1_42/boost/type_traits/remove_cv.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/type_traits/cv_traits.hpp" 2
+# 12 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/type.hpp"
+namespace boost {
+
+
+
+  template <class T>
+  struct type {};
+
+}
+# 13 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/base_type_traits.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/base_type_traits.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  struct unspecialized {};
+}
+
+
+
+template <class T> struct base_type_traits
+  : detail::unspecialized
+{};
+
+template <>
+struct base_type_traits<PyObject>
+{
+    typedef PyObject type;
+};
+
+template <>
+struct base_type_traits<PyTypeObject>
+{
+    typedef PyObject type;
+};
+
+template <>
+struct base_type_traits<PyMethodObject>
+{
+    typedef PyObject type;
+};
+
+}}
+# 14 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/convertible.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/detail/convertible.hpp"
+namespace boost { namespace python { namespace detail {
+
+typedef char* yes_convertible;
+typedef int* no_convertible;
+
+template <class Target>
+struct convertible
+{
+
+    static inline no_convertible check(...) { return 0; }
+    static inline yes_convertible check(Target) { return 0; }
+# 34 "/usr/include/boost-1_42/boost/python/detail/convertible.hpp"
+};
+
+}}}
+# 15 "/usr/include/boost-1_42/boost/python/cast.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class Source, class Target> inline Target* upcast_impl(Source*, Target*);
+
+  template <class Source, class Target>
+  inline Target* upcast(Source* p, yes_convertible, no_convertible, Target*)
+  {
+      return p;
+  }
+
+  template <class Source, class Target>
+  inline Target* upcast(Source* p, no_convertible, no_convertible, Target*)
+  {
+      typedef typename base_type_traits<Source>::type base;
+
+      return detail::upcast_impl((base*)p, (Target*)0);
+  }
+
+  template <bool is_same = true>
+  struct upcaster
+  {
+      template <class T>
+      static inline T* execute(T* x, T*) { return x; }
+  };
+
+  template <>
+  struct upcaster<false>
+  {
+      template <class Source, class Target>
+      static inline Target* execute(Source* x, Target*)
+      {
+          return detail::upcast(
+              x, detail::convertible<Target*>::check(x)
+              , detail::convertible<Source*>::check((Target*)0)
+              , (Target*)0);
+      }
+  };
+
+
+  template <class Target, class Source>
+  inline Target* downcast(Source* p, yes_convertible)
+  {
+      return static_cast<Target*>(p);
+  }
+
+  template <class Target, class Source>
+  inline Target* downcast(Source* p, no_convertible, boost::type<Target>* = 0)
+  {
+      typedef typename base_type_traits<Source>::type base;
+      return (Target*)detail::downcast<base>(p, convertible<Source*>::check((base*)0));
+  }
+
+  template <class T>
+  inline void assert_castable(boost::type<T>* = 0)
+  {
+      typedef char must_be_a_complete_type[sizeof(T)];
+  }
+
+  template <class Source, class Target>
+  inline Target* upcast_impl(Source* x, Target*)
+  {
+      typedef typename add_cv<Source>::type src_t;
+      typedef typename add_cv<Target>::type target_t;
+      bool const same = is_same<src_t,target_t>::value;
+
+      return detail::upcaster<same>::execute(x, (Target*)0);
+  }
+}
+
+template <class Target, class Source>
+inline Target* upcast(Source* x, Target* = 0)
+{
+    detail::assert_castable<Source>();
+    detail::assert_castable<Target>();
+    return detail::upcast_impl(x, (Target*)0);
+
+}
+
+template <class Target, class Source>
+inline Target* downcast(Source* x, Target* = 0)
+{
+    detail::assert_castable<Source>();
+    detail::assert_castable<Target>();
+    return detail::downcast<Target>(x, detail::convertible<Source*>::check((Target*)0));
+}
+
+}}
+# 11 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/errors.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/errors.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/function0.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/function/function0.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/function_template.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 1 3
+# 43 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 3
+       
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 3
+
+# 1 "/usr/include/assert.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cassert" 2 3
+# 13 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 1 3
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 3
+       
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 3
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstdlib" 2 3
+# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+       
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 199 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _FIter, typename _Tp>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    bool
+    binary_search(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    copy(_IIter, _IIter, _OIter);
+
+  template<typename _BIter1, typename _BIter2>
+    _BIter2
+    copy_backward(_BIter1, _BIter1, _BIter2);
+# 228 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _FIter, typename _Tp>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    pair<_FIter, _FIter>
+    equal_range(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _FIter, typename _Tp>
+    void
+    fill(_FIter, _FIter, const _Tp&);
+
+  template<typename _OIter, typename _Size, typename _Tp>
+    _OIter
+    fill_n(_OIter, _Size, const _Tp&);
+
+
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+# 267 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _IIter1, typename _IIter2>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _BIter>
+    void
+    inplace_merge(_BIter, _BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    void
+    inplace_merge(_BIter, _BIter, _BIter, _Compare);
+# 321 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _FIter1, typename _FIter2>
+    void
+    iter_swap(_FIter1, _FIter2);
+
+  template<typename _FIter, typename _Tp>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    lower_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+  template<typename _RAIter>
+    void
+    make_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    make_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _Tp>
+    const _Tp&
+    max(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    const _Tp&
+    max(const _Tp&, const _Tp&, _Compare);
+
+
+
+
+  template<typename _Tp>
+    const _Tp&
+    min(const _Tp&, const _Tp&);
+
+  template<typename _Tp, typename _Compare>
+    const _Tp&
+    min(const _Tp&, const _Tp&, _Compare);
+# 406 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _BIter>
+    bool
+    next_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool
+    next_permutation(_BIter, _BIter, _Compare);
+# 423 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _IIter, typename _RAIter>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
+
+  template<typename _IIter, typename _RAIter, typename _Compare>
+    _RAIter
+    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
+# 444 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _RAIter>
+    void
+    pop_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    pop_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter>
+    bool
+    prev_permutation(_BIter, _BIter);
+
+  template<typename _BIter, typename _Compare>
+    bool
+    prev_permutation(_BIter, _BIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    push_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    push_heap(_RAIter, _RAIter, _Compare);
+
+
+
+  template<typename _FIter, typename _Tp>
+    _FIter
+    remove(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Predicate>
+    _FIter
+    remove_if(_FIter, _FIter, _Predicate);
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    remove_copy(_IIter, _IIter, _OIter, const _Tp&);
+
+  template<typename _IIter, typename _OIter, typename _Predicate>
+    _OIter
+    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
+
+
+
+  template<typename _IIter, typename _OIter, typename _Tp>
+    _OIter
+    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
+
+  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
+    _OIter
+    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
+
+
+
+  template<typename _BIter>
+    void
+    reverse(_BIter, _BIter);
+
+  template<typename _BIter, typename _OIter>
+    _OIter
+    reverse_copy(_BIter, _BIter, _OIter);
+
+  template<typename _FIter>
+    void
+    rotate(_FIter, _FIter, _FIter);
+
+  template<typename _FIter, typename _OIter>
+    _OIter
+    rotate_copy(_FIter, _FIter, _FIter, _OIter);
+# 527 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/algorithmfwd.h" 3
+  template<typename _RAIter>
+    void
+    sort_heap(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    sort_heap(_RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    stable_partition(_BIter, _BIter, _Predicate);
+
+  template<typename _Tp>
+    void
+    swap(_Tp&, _Tp&);
+
+  template<typename _Tp, size_t _Nm>
+    void
+    swap(_Tp (&)[_Nm], _Tp (&)[_Nm]);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter2
+    swap_ranges(_FIter1, _FIter1, _FIter2);
+
+
+
+  template<typename _FIter>
+    _FIter
+    unique(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    unique(_FIter, _FIter, _BinaryPredicate);
+
+
+
+  template<typename _FIter, typename _Tp>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&);
+
+  template<typename _FIter, typename _Tp, typename _Compare>
+    _FIter
+    upper_bound(_FIter, _FIter, const _Tp&, _Compare);
+
+}
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _FIter>
+    _FIter
+    adjacent_find(_FIter, _FIter);
+
+  template<typename _FIter, typename _BinaryPredicate>
+    _FIter
+    adjacent_find(_FIter, _FIter, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+    typename iterator_traits<_IIter>::difference_type
+    count(_IIter, _IIter, const _Tp&);
+
+  template<typename _IIter, typename _Predicate>
+    typename iterator_traits<_IIter>::difference_type
+    count_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    equal(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    bool
+    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Tp>
+    _IIter
+    find(_IIter, _IIter, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _IIter, typename _Predicate>
+    _IIter
+    find_if(_IIter, _IIter, _Predicate);
+
+  template<typename _IIter, typename _Funct>
+    _Funct
+    for_each(_IIter, _IIter, _Funct);
+
+  template<typename _FIter, typename _Generator>
+    void
+    generate(_FIter, _FIter, _Generator);
+
+  template<typename _OIter, typename _Size, typename _Generator>
+    _OIter
+    generate_n(_OIter, _Size, _Generator);
+
+  template<typename _IIter1, typename _IIter2>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _Compare>
+    bool
+    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
+
+  template<typename _FIter>
+    _FIter
+    max_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    max_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _FIter>
+    _FIter
+    min_element(_FIter, _FIter);
+
+  template<typename _FIter, typename _Compare>
+    _FIter
+    min_element(_FIter, _FIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2);
+
+  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
+    pair<_IIter1, _IIter2>
+    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
+
+  template<typename _RAIter>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    nth_element(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
+
+  template<typename _BIter, typename _Predicate>
+    _BIter
+    partition(_BIter, _BIter, _Predicate);
+
+  template<typename _RAIter>
+    void
+    random_shuffle(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Generator>
+    void
+    random_shuffle(_RAIter, _RAIter,
+
+
+
+     _Generator&);
+
+
+  template<typename _FIter, typename _Tp>
+    void
+    replace(_FIter, _FIter, const _Tp&, const _Tp&);
+
+  template<typename _FIter, typename _Predicate, typename _Tp>
+    void
+    replace_if(_FIter, _FIter, _Predicate, const _Tp&);
+
+  template<typename _FIter1, typename _FIter2>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2);
+
+  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
+    _FIter1
+    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
+
+  template<typename _FIter, typename _Size, typename _Tp>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&);
+
+  template<typename _FIter, typename _Size, typename _Tp,
+    typename _BinaryPredicate>
+    _FIter
+    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
+        _OIter, _Compare);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _Compare>
+    _OIter
+    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _RAIter>
+    void
+    stable_sort(_RAIter, _RAIter);
+
+  template<typename _RAIter, typename _Compare>
+    void
+    stable_sort(_RAIter, _RAIter, _Compare);
+
+  template<typename _IIter, typename _OIter, typename _UnaryOperation>
+    _OIter
+    transform(_IIter, _IIter, _OIter, _UnaryOperation);
+
+  template<typename _IIter1, typename _IIter2, typename _OIter,
+    typename _BinaryOperation>
+    _OIter
+    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
+
+  template<typename _IIter, typename _OIter>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter);
+
+  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
+    _OIter
+    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
+
+}
+# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 1 3
+# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+ {
+   if (__first[__parent] < __first[__child])
+     return __child;
+   if ((__child & 1) == 0)
+     ++__parent;
+ }
+      return __n;
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    _Distance
+    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
+      _Compare __comp)
+    {
+      _Distance __parent = 0;
+      for (_Distance __child = 1; __child < __n; ++__child)
+ {
+   if (__comp(__first[__parent], __first[__child]))
+     return __child;
+   if ((__child & 1) == 0)
+     ++__parent;
+ }
+      return __n;
+    }
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Distance __n)
+    { return std::__is_heap_until(__first, __n) == __n; }
+
+  template<typename _RandomAccessIterator, typename _Compare,
+    typename _Distance>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
+    { return std::__is_heap_until(__first, __n, __comp) == __n; }
+
+  template<typename _RandomAccessIterator>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    { return std::__is_heap(__first, std::distance(__first, __last)); }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline bool
+    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    { return std::__is_heap(__first, __comp, std::distance(__first, __last)); }
+
+
+
+
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
+    void
+    __push_heap(_RandomAccessIterator __first,
+  _Distance __holeIndex, _Distance __topIndex, _Tp __value)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex && *(__first + __parent) < __value)
+ {
+   *(__first + __holeIndex) = (*(__first + __parent));
+   __holeIndex = __parent;
+   __parent = (__holeIndex - 1) / 2;
+ }
+      *(__first + __holeIndex) = (__value);
+    }
+# 152 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+     
+      ;
+      ;
+
+      _ValueType __value = (*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), (__value));
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
+    typename _Compare>
+    void
+    __push_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+  _Distance __topIndex, _Tp __value, _Compare __comp)
+    {
+      _Distance __parent = (__holeIndex - 1) / 2;
+      while (__holeIndex > __topIndex
+      && __comp(*(__first + __parent), __value))
+ {
+   *(__first + __holeIndex) = (*(__first + __parent));
+   __holeIndex = __parent;
+   __parent = (__holeIndex - 1) / 2;
+ }
+      *(__first + __holeIndex) = (__value);
+    }
+# 201 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+      ;
+      ;
+
+      _ValueType __value = (*(__last - 1));
+      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
+         _DistanceType(0), (__value), __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance, typename _Tp>
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+    _Distance __len, _Tp __value)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   if (*(__first + __secondChild) < *(__first + (__secondChild - 1)))
+     __secondChild--;
+   *(__first + __holeIndex) = (*(__first + __secondChild));
+   __holeIndex = __secondChild;
+ }
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
+                                  ;
+   __holeIndex = __secondChild - 1;
+ }
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         (__value));
+    }
+
+  template<typename _RandomAccessIterator>
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+        _RandomAccessIterator __result)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      _ValueType __value = (*__result);
+      *__result = (*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+    _DistanceType(__last - __first),
+    (__value));
+    }
+# 274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+      ;
+      ;
+
+      --__last;
+      std::__pop_heap(__first, __last, __last);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Tp, typename _Compare>
+    void
+    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
+    _Distance __len, _Tp __value, _Compare __comp)
+    {
+      const _Distance __topIndex = __holeIndex;
+      _Distance __secondChild = __holeIndex;
+      while (__secondChild < (__len - 1) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   if (__comp(*(__first + __secondChild),
+       *(__first + (__secondChild - 1))))
+     __secondChild--;
+   *(__first + __holeIndex) = (*(__first + __secondChild));
+   __holeIndex = __secondChild;
+ }
+      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
+ {
+   __secondChild = 2 * (__secondChild + 1);
+   *(__first + __holeIndex) = (*(__first + (__secondChild - 1)))
+                                  ;
+   __holeIndex = __secondChild - 1;
+ }
+      std::__push_heap(__first, __holeIndex, __topIndex,
+         (__value), __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+        _RandomAccessIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+      _ValueType __value = (*__result);
+      *__result = (*__first);
+      std::__adjust_heap(__first, _DistanceType(0),
+    _DistanceType(__last - __first),
+    (__value), __comp);
+    }
+# 348 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    pop_heap(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      --__last;
+      std::__pop_heap(__first, __last, __last, __comp);
+    }
+# 371 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+     
+      ;
+
+      if (__last - __first < 2)
+ return;
+
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+ {
+   _ValueType __value = (*(__first + __parent));
+   std::__adjust_heap(__first, __parent, __len, (__value));
+   if (__parent == 0)
+     return;
+   __parent--;
+ }
+    }
+# 411 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+   _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+   _DistanceType;
+
+
+     
+
+      ;
+
+      if (__last - __first < 2)
+ return;
+
+      const _DistanceType __len = __last - __first;
+      _DistanceType __parent = (__len - 2) / 2;
+      while (true)
+ {
+   _ValueType __value = (*(__first + __parent));
+   std::__adjust_heap(__first, __parent, __len, (__value),
+        __comp);
+   if (__parent == 0)
+     return;
+   __parent--;
+ }
+    }
+# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator>
+    void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+     
+
+      ;
+      ;
+
+      while (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last);
+ }
+    }
+# 479 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Compare __comp)
+    {
+
+     
+
+      ;
+      ;
+
+      while (__last - __first > 1)
+ {
+   --__last;
+   std::__pop_heap(__first, __last, __last, __comp);
+ }
+    }
+# 576 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_heap.h" 3
+}
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 1 3
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    pair<_Tp*, ptrdiff_t>
+    get_temporary_buffer(ptrdiff_t __len)
+    {
+      const ptrdiff_t __max =
+ __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
+      if (__len > __max)
+ __len = __max;
+
+      while (__len > 0)
+ {
+   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
+       std::nothrow));
+   if (__tmp != 0)
+     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
+   __len /= 2;
+ }
+      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
+    }
+# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tempbuf.h" 3
+  template<typename _Tp>
+    inline void
+    return_temporary_buffer(_Tp* __p)
+    { ::operator delete(__p, std::nothrow); }
+
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _Tp>
+    class _Temporary_buffer
+    {
+
+     
+
+    public:
+      typedef _Tp value_type;
+      typedef value_type* pointer;
+      typedef pointer iterator;
+      typedef ptrdiff_t size_type;
+
+    protected:
+      size_type _M_original_len;
+      size_type _M_len;
+      pointer _M_buffer;
+
+    public:
+
+      size_type
+      size() const
+      { return _M_len; }
+
+
+      size_type
+      requested_size() const
+      { return _M_original_len; }
+
+
+      iterator
+      begin()
+      { return _M_buffer; }
+
+
+      iterator
+      end()
+      { return _M_buffer + _M_len; }
+
+
+
+
+
+      _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last);
+
+      ~_Temporary_buffer()
+      {
+ std::_Destroy(_M_buffer, _M_buffer + _M_len);
+ std::return_temporary_buffer(_M_buffer);
+      }
+
+    private:
+
+      _Temporary_buffer(const _Temporary_buffer&);
+
+      void
+      operator=(const _Temporary_buffer&);
+    };
+
+  template<typename _ForwardIterator, typename _Tp>
+    _Temporary_buffer<_ForwardIterator, _Tp>::
+    _Temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
+    : _M_original_len(std::distance(__first, __last)),
+      _M_len(0), _M_buffer(0)
+    {
+      try
+ {
+   std::pair<pointer, size_type> __p(std::get_temporary_buffer<
+         value_type>(_M_original_len));
+   _M_buffer = __p.first;
+   _M_len = __p.second;
+   if(_M_buffer)
+     std::__uninitialized_construct_range(_M_buffer, _M_buffer + _M_len,
+       *__first);
+ }
+      catch(...)
+ {
+   std::return_temporary_buffer(_M_buffer);
+   _M_buffer = 0;
+   _M_len = 0;
+   throw;
+ }
+    }
+
+}
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 2 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  template<typename _Iterator>
+    void
+    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c)
+    {
+
+     
+
+
+      if (*__a < *__b)
+ {
+   if (*__b < *__c)
+     std::iter_swap(__a, __b);
+   else if (*__a < *__c)
+     std::iter_swap(__a, __c);
+ }
+      else if (*__a < *__c)
+ return;
+      else if (*__b < *__c)
+ std::iter_swap(__a, __c);
+      else
+ std::iter_swap(__a, __b);
+    }
+
+
+  template<typename _Iterator, typename _Compare>
+    void
+    __move_median_first(_Iterator __a, _Iterator __b, _Iterator __c,
+   _Compare __comp)
+    {
+
+     
+
+
+
+      if (__comp(*__a, *__b))
+ {
+   if (__comp(*__b, *__c))
+     std::iter_swap(__a, __b);
+   else if (__comp(*__a, *__c))
+     std::iter_swap(__a, __c);
+ }
+      else if (__comp(*__a, *__c))
+ return;
+      else if (__comp(*__b, *__c))
+ std::iter_swap(__a, __c);
+      else
+ std::iter_swap(__a, __b);
+    }
+
+
+
+
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    __find(_InputIterator __first, _InputIterator __last,
+    const _Tp& __val, input_iterator_tag)
+    {
+      while (__first != __last && !(*__first == __val))
+ ++__first;
+      return __first;
+    }
+
+
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    __find_if(_InputIterator __first, _InputIterator __last,
+       _Predicate __pred, input_iterator_tag)
+    {
+      while (__first != __last && !bool(__pred(*__first)))
+ ++__first;
+      return __first;
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Tp>
+    _RandomAccessIterator
+    __find(_RandomAccessIterator __first, _RandomAccessIterator __last,
+    const _Tp& __val, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+ __trip_count = (__last - __first) >> 2;
+
+      for (; __trip_count > 0; --__trip_count)
+ {
+   if (*__first == __val)
+     return __first;
+   ++__first;
+
+   if (*__first == __val)
+     return __first;
+   ++__first;
+
+   if (*__first == __val)
+     return __first;
+   ++__first;
+
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ }
+
+      switch (__last - __first)
+ {
+ case 3:
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ case 2:
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ case 1:
+   if (*__first == __val)
+     return __first;
+   ++__first;
+ case 0:
+ default:
+   return __last;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Predicate>
+    _RandomAccessIterator
+    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       _Predicate __pred, random_access_iterator_tag)
+    {
+      typename iterator_traits<_RandomAccessIterator>::difference_type
+ __trip_count = (__last - __first) >> 2;
+
+      for (; __trip_count > 0; --__trip_count)
+ {
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ }
+
+      switch (__last - __first)
+ {
+ case 3:
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ case 2:
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ case 1:
+   if (__pred(*__first))
+     return __first;
+   ++__first;
+ case 0:
+ default:
+   return __last;
+ }
+    }
+# 322 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count, const _Tp& __val,
+        std::forward_iterator_tag)
+    {
+      __first = std::find(__first, __last, __val);
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && *__i == __val)
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = std::find(++__i, __last, __val);
+ }
+      return __last;
+    }
+
+
+
+
+
+
+  template<typename _RandomAccessIter, typename _Integer, typename _Tp>
+    _RandomAccessIter
+    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
+        _Integer __count, const _Tp& __val,
+        std::random_access_iterator_tag)
+    {
+
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+
+      _DistanceType __tailSize = __last - __first;
+      const _DistanceType __pattSize = __count;
+
+      if (__tailSize < __pattSize)
+        return __last;
+
+      const _DistanceType __skipOffset = __pattSize - 1;
+      _RandomAccessIter __lookAhead = __first + __skipOffset;
+      __tailSize -= __pattSize;
+
+      while (1)
+ {
+
+
+   while (!(*__lookAhead == __val))
+     {
+       if (__tailSize < __pattSize)
+  return __last;
+       __lookAhead += __pattSize;
+       __tailSize -= __pattSize;
+     }
+   _DistanceType __remainder = __skipOffset;
+   for (_RandomAccessIter __backTrack = __lookAhead - 1;
+        *__backTrack == __val; --__backTrack)
+     {
+       if (--__remainder == 0)
+  return (__lookAhead - __skipOffset);
+     }
+   if (__remainder > __tailSize)
+     return __last;
+   __lookAhead += __remainder;
+   __tailSize -= __remainder;
+ }
+    }
+# 407 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    _ForwardIterator
+    __search_n(_ForwardIterator __first, _ForwardIterator __last,
+        _Integer __count, const _Tp& __val,
+        _BinaryPredicate __binary_pred, std::forward_iterator_tag)
+    {
+      while (__first != __last && !bool(__binary_pred(*__first, __val)))
+        ++__first;
+
+      while (__first != __last)
+ {
+   typename iterator_traits<_ForwardIterator>::difference_type
+     __n = __count;
+   _ForwardIterator __i = __first;
+   ++__i;
+   while (__i != __last && __n != 1 && bool(__binary_pred(*__i, __val)))
+     {
+       ++__i;
+       --__n;
+     }
+   if (__n == 1)
+     return __first;
+   if (__i == __last)
+     return __last;
+   __first = ++__i;
+   while (__first != __last
+   && !bool(__binary_pred(*__first, __val)))
+     ++__first;
+ }
+      return __last;
+    }
+
+
+
+
+
+
+
+  template<typename _RandomAccessIter, typename _Integer, typename _Tp,
+    typename _BinaryPredicate>
+    _RandomAccessIter
+    __search_n(_RandomAccessIter __first, _RandomAccessIter __last,
+        _Integer __count, const _Tp& __val,
+        _BinaryPredicate __binary_pred, std::random_access_iterator_tag)
+    {
+
+      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
+ _DistanceType;
+
+      _DistanceType __tailSize = __last - __first;
+      const _DistanceType __pattSize = __count;
+
+      if (__tailSize < __pattSize)
+        return __last;
+
+      const _DistanceType __skipOffset = __pattSize - 1;
+      _RandomAccessIter __lookAhead = __first + __skipOffset;
+      __tailSize -= __pattSize;
+
+      while (1)
+ {
+
+
+   while (!bool(__binary_pred(*__lookAhead, __val)))
+     {
+       if (__tailSize < __pattSize)
+  return __last;
+       __lookAhead += __pattSize;
+       __tailSize -= __pattSize;
+     }
+   _DistanceType __remainder = __skipOffset;
+   for (_RandomAccessIter __backTrack = __lookAhead - 1;
+        __binary_pred(*__backTrack, __val); --__backTrack)
+     {
+       if (--__remainder == 0)
+  return (__lookAhead - __skipOffset);
+     }
+   if (__remainder > __tailSize)
+     return __last;
+   __lookAhead += __remainder;
+   __tailSize -= __remainder;
+ }
+    }
+
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+        forward_iterator_tag, forward_iterator_tag)
+    {
+      if (__first2 == __last2)
+ return __last1;
+      else
+ {
+   _ForwardIterator1 __result = __last1;
+   while (1)
+     {
+       _ForwardIterator1 __new_result
+  = std::search(__first1, __last1, __first2, __last2);
+       if (__new_result == __last1)
+  return __result;
+       else
+  {
+    __result = __new_result;
+    __first1 = __new_result;
+    ++__first1;
+  }
+     }
+ }
+    }
+
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+        forward_iterator_tag, forward_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+      if (__first2 == __last2)
+ return __last1;
+      else
+ {
+   _ForwardIterator1 __result = __last1;
+   while (1)
+     {
+       _ForwardIterator1 __new_result
+  = std::search(__first1, __last1, __first2,
+      __last2, __comp);
+       if (__new_result == __last1)
+  return __result;
+       else
+  {
+    __result = __new_result;
+    __first1 = __new_result;
+    ++__first1;
+  }
+     }
+ }
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+        _BidirectionalIterator1 __last1,
+        _BidirectionalIterator2 __first2,
+        _BidirectionalIterator2 __last2,
+        bidirectional_iterator_tag, bidirectional_iterator_tag)
+    {
+
+     
+
+     
+
+
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::search(_RevIterator1(__last1),
+             __rlast1,
+             _RevIterator2(__last2),
+             __rlast2);
+
+      if (__rresult == __rlast1)
+ return __last1;
+      else
+ {
+   _BidirectionalIterator1 __result = __rresult.base();
+   std::advance(__result, -std::distance(__first2, __last2));
+   return __result;
+ }
+    }
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BinaryPredicate>
+    _BidirectionalIterator1
+    __find_end(_BidirectionalIterator1 __first1,
+        _BidirectionalIterator1 __last1,
+        _BidirectionalIterator2 __first2,
+        _BidirectionalIterator2 __last2,
+        bidirectional_iterator_tag, bidirectional_iterator_tag,
+        _BinaryPredicate __comp)
+    {
+
+     
+
+     
+
+
+      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
+      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;
+
+      _RevIterator1 __rlast1(__first1);
+      _RevIterator2 __rlast2(__first2);
+      _RevIterator1 __rresult = std::search(_RevIterator1(__last1), __rlast1,
+         _RevIterator2(__last2), __rlast2,
+         __comp);
+
+      if (__rresult == __rlast1)
+ return __last1;
+      else
+ {
+   _BidirectionalIterator1 __result = __rresult.base();
+   std::advance(__result, -std::distance(__first2, __last2));
+   return __result;
+ }
+    }
+# 645 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2));
+    }
+# 691 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    inline _ForwardIterator1
+    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+      _BinaryPredicate __comp)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      return std::__find_end(__first1, __last1, __first2, __last2,
+        std::__iterator_category(__first1),
+        std::__iterator_category(__first2),
+        __comp);
+    }
+# 870 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    _OutputIterator
+    remove_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result, const _Tp& __value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (!(*__first == __value))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+# 907 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate>
+    _OutputIterator
+    remove_copy_if(_InputIterator __first, _InputIterator __last,
+     _OutputIterator __result, _Predicate __pred)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (!bool(__pred(*__first)))
+   {
+     *__result = *__first;
+     ++__result;
+   }
+      return __result;
+    }
+# 1082 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    remove(_ForwardIterator __first, _ForwardIterator __last,
+    const _Tp& __value)
+    {
+
+     
+
+     
+
+      ;
+
+      __first = std::find(__first, __last, __value);
+      if(__first == __last)
+        return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for(; __first != __last; ++__first)
+        if(!(*__first == __value))
+          {
+            *__result = (*__first);
+            ++__result;
+          }
+      return __result;
+    }
+# 1125 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    remove_if(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      __first = std::find_if(__first, __last, __pred);
+      if(__first == __last)
+        return __first;
+      _ForwardIterator __result = __first;
+      ++__first;
+      for(; __first != __last; ++__first)
+        if(!bool(__pred(*__first)))
+          {
+            *__result = (*__first);
+            ++__result;
+          }
+      return __result;
+    }
+# 1165 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+
+      __first = std::adjacent_find(__first, __last);
+      if (__first == __last)
+ return __last;
+
+
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+ if (!(*__dest == *__first))
+   *++__dest = (*__first);
+      return ++__dest;
+    }
+# 1205 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    unique(_ForwardIterator __first, _ForwardIterator __last,
+           _BinaryPredicate __binary_pred)
+    {
+
+     
+
+     
+
+
+      ;
+
+
+      __first = std::adjacent_find(__first, __last, __binary_pred);
+      if (__first == __last)
+ return __last;
+
+
+      _ForwardIterator __dest = __first;
+      ++__first;
+      while (++__first != __last)
+ if (!bool(__binary_pred(*__dest, *__first)))
+   *++__dest = (*__first);
+      return ++__dest;
+    }
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _OutputIterator>
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+    _OutputIterator __result,
+    forward_iterator_tag, output_iterator_tag)
+    {
+
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+ if (!(*__first == *__next))
+   {
+     __first = __next;
+     *++__result = *__first;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+  template<typename _InputIterator, typename _OutputIterator>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result,
+    input_iterator_tag, output_iterator_tag)
+    {
+
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ if (!(__value == *__first))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _ForwardIterator __result,
+    input_iterator_tag, forward_iterator_tag)
+    {
+
+      *__result = *__first;
+      while (++__first != __last)
+ if (!(*__result == *__first))
+   *++__result = *__first;
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<typename _ForwardIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    forward_iterator_tag, output_iterator_tag)
+    {
+
+     
+
+
+
+      _ForwardIterator __next = __first;
+      *__result = *__first;
+      while (++__next != __last)
+ if (!bool(__binary_pred(*__first, *__next)))
+   {
+     __first = __next;
+     *++__result = *__first;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    _OutputIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _OutputIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, output_iterator_tag)
+    {
+
+     
+
+
+
+      typename iterator_traits<_InputIterator>::value_type __value = *__first;
+      *__result = __value;
+      while (++__first != __last)
+ if (!bool(__binary_pred(__value, *__first)))
+   {
+     __value = *__first;
+     *++__result = __value;
+   }
+      return ++__result;
+    }
+
+
+
+
+
+
+
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _ForwardIterator
+    __unique_copy(_InputIterator __first, _InputIterator __last,
+    _ForwardIterator __result, _BinaryPredicate __binary_pred,
+    input_iterator_tag, forward_iterator_tag)
+    {
+
+     
+
+
+
+      *__result = *__first;
+      while (++__first != __last)
+ if (!bool(__binary_pred(*__result, *__first)))
+   *++__result = *__first;
+      return ++__result;
+    }
+
+
+
+
+
+
+  template<typename _BidirectionalIterator>
+    void
+    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+      while (true)
+ if (__first == __last || __first == --__last)
+   return;
+ else
+   {
+     std::iter_swap(__first, __last);
+     ++__first;
+   }
+    }
+
+
+
+
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
+       random_access_iterator_tag)
+    {
+      if (__first == __last)
+ return;
+      --__last;
+      while (__first < __last)
+ {
+   std::iter_swap(__first, __last);
+   ++__first;
+   --__last;
+ }
+    }
+# 1433 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    inline void
+    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
+    {
+
+     
+
+      ;
+      std::__reverse(__first, __last, std::__iterator_category(__first));
+    }
+# 1460 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _OutputIterator>
+    _OutputIterator
+    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
+   _OutputIterator __result)
+    {
+
+     
+
+     
+
+      ;
+
+      while (__first != __last)
+ {
+   --__last;
+   *__result = *__last;
+   ++__result;
+ }
+      return __result;
+    }
+
+
+
+
+
+  template<typename _EuclideanRingElement>
+    _EuclideanRingElement
+    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
+    {
+      while (__n != 0)
+ {
+   _EuclideanRingElement __t = __m % __n;
+   __m = __n;
+   __n = __t;
+ }
+      return __m;
+    }
+
+
+  template<typename _ForwardIterator>
+    void
+    __rotate(_ForwardIterator __first,
+      _ForwardIterator __middle,
+      _ForwardIterator __last,
+      forward_iterator_tag)
+    {
+      if (__first == __middle || __last == __middle)
+ return;
+
+      _ForwardIterator __first2 = __middle;
+      do
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+ }
+      while (__first2 != __last);
+
+      __first2 = __middle;
+
+      while (__first2 != __last)
+ {
+   std::iter_swap(__first, __first2);
+   ++__first;
+   ++__first2;
+   if (__first == __middle)
+     __middle = __first2;
+   else if (__first2 == __last)
+     __first2 = __middle;
+ }
+    }
+
+
+  template<typename _BidirectionalIterator>
+    void
+    __rotate(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+       bidirectional_iterator_tag)
+    {
+
+     
+
+
+      if (__first == __middle || __last == __middle)
+ return;
+
+      std::__reverse(__first, __middle, bidirectional_iterator_tag());
+      std::__reverse(__middle, __last, bidirectional_iterator_tag());
+
+      while (__first != __middle && __middle != __last)
+ {
+   std::iter_swap(__first, --__last);
+   ++__first;
+ }
+
+      if (__first == __middle)
+ std::__reverse(__middle, __last, bidirectional_iterator_tag());
+      else
+ std::__reverse(__first, __middle, bidirectional_iterator_tag());
+    }
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __rotate(_RandomAccessIterator __first,
+      _RandomAccessIterator __middle,
+      _RandomAccessIterator __last,
+      random_access_iterator_tag)
+    {
+
+     
+
+
+      if (__first == __middle || __last == __middle)
+ return;
+
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      _Distance __n = __last - __first;
+      _Distance __k = __middle - __first;
+
+      if (__k == __n - __k)
+ {
+   std::swap_ranges(__first, __middle, __middle);
+   return;
+ }
+
+      _RandomAccessIterator __p = __first;
+
+      for (;;)
+ {
+   if (__k < __n - __k)
+     {
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = (*__p);
+    std::copy(__p + 1, __p + __n, __p);
+    *(__p + __n - 1) = (__t);
+    return;
+  }
+       _RandomAccessIterator __q = __p + __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    std::iter_swap(__p, __q);
+    ++__p;
+    ++__q;
+  }
+       __n %= __k;
+       if (__n == 0)
+  return;
+       std::swap(__n, __k);
+       __k = __n - __k;
+     }
+   else
+     {
+       __k = __n - __k;
+       if (__is_pod(_ValueType) && __k == 1)
+  {
+    _ValueType __t = (*(__p + __n - 1));
+    std::copy_backward(__p, __p + __n - 1, __p + __n);
+    *__p = (__t);
+    return;
+  }
+       _RandomAccessIterator __q = __p + __n;
+       __p = __q - __k;
+       for (_Distance __i = 0; __i < __n - __k; ++ __i)
+  {
+    --__p;
+    --__q;
+    std::iter_swap(__p, __q);
+  }
+       __n %= __k;
+       if (__n == 0)
+  return;
+       std::swap(__n, __k);
+     }
+ }
+    }
+# 1664 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    inline void
+    rotate(_ForwardIterator __first, _ForwardIterator __middle,
+    _ForwardIterator __last)
+    {
+
+     
+
+      ;
+      ;
+
+      typedef typename iterator_traits<_ForwardIterator>::iterator_category
+ _IterType;
+      std::__rotate(__first, __middle, __last, _IterType());
+    }
+# 1698 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _OutputIterator>
+    _OutputIterator
+    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
+                _ForwardIterator __last, _OutputIterator __result)
+    {
+
+     
+     
+
+      ;
+      ;
+
+      return std::copy(__first, __middle,
+                       std::copy(__middle, __last, __result));
+    }
+
+
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    __partition(_ForwardIterator __first, _ForwardIterator __last,
+  _Predicate __pred, forward_iterator_tag)
+    {
+      if (__first == __last)
+ return __first;
+
+      while (__pred(*__first))
+ if (++__first == __last)
+   return __first;
+
+      _ForwardIterator __next = __first;
+
+      while (++__next != __last)
+ if (__pred(*__next))
+   {
+     std::iter_swap(__first, __next);
+     ++__first;
+   }
+
+      return __first;
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Predicate>
+    _BidirectionalIterator
+    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
+  _Predicate __pred, bidirectional_iterator_tag)
+    {
+      while (true)
+ {
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (__pred(*__first))
+       ++__first;
+     else
+       break;
+   --__last;
+   while (true)
+     if (__first == __last)
+       return __first;
+     else if (!bool(__pred(*__last)))
+       --__last;
+     else
+       break;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+
+
+
+
+  template<typename _ForwardIterator, typename _Predicate, typename _Distance>
+    _ForwardIterator
+    __inplace_stable_partition(_ForwardIterator __first,
+          _ForwardIterator __last,
+          _Predicate __pred, _Distance __len)
+    {
+      if (__len == 1)
+ return __pred(*__first) ? __last : __first;
+      _ForwardIterator __middle = __first;
+      std::advance(__middle, __len / 2);
+      _ForwardIterator __begin = std::__inplace_stable_partition(__first,
+         __middle,
+         __pred,
+         __len / 2);
+      _ForwardIterator __end = std::__inplace_stable_partition(__middle, __last,
+              __pred,
+              __len
+              - __len / 2);
+      std::rotate(__begin, __middle, __end);
+      std::advance(__begin, std::distance(__middle, __end));
+      return __begin;
+    }
+
+
+  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
+    typename _Distance>
+    _ForwardIterator
+    __stable_partition_adaptive(_ForwardIterator __first,
+    _ForwardIterator __last,
+    _Predicate __pred, _Distance __len,
+    _Pointer __buffer,
+    _Distance __buffer_size)
+    {
+      if (__len <= __buffer_size)
+ {
+   _ForwardIterator __result1 = __first;
+   _Pointer __result2 = __buffer;
+   for (; __first != __last; ++__first)
+     if (__pred(*__first))
+       {
+  *__result1 = (*__first);
+  ++__result1;
+       }
+     else
+       {
+  *__result2 = (*__first);
+  ++__result2;
+       }
+   std::copy(__buffer, __result2, __result1);
+   return __result1;
+ }
+      else
+ {
+   _ForwardIterator __middle = __first;
+   std::advance(__middle, __len / 2);
+   _ForwardIterator __begin =
+     std::__stable_partition_adaptive(__first, __middle, __pred,
+          __len / 2, __buffer,
+          __buffer_size);
+   _ForwardIterator __end =
+     std::__stable_partition_adaptive(__middle, __last, __pred,
+          __len - __len / 2,
+          __buffer, __buffer_size);
+   std::rotate(__begin, __middle, __end);
+   std::advance(__begin, std::distance(__middle, __end));
+   return __begin;
+ }
+    }
+# 1856 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    _ForwardIterator
+    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      if (__first == __last)
+ return __first;
+      else
+ {
+   typedef typename iterator_traits<_ForwardIterator>::value_type
+     _ValueType;
+   typedef typename iterator_traits<_ForwardIterator>::difference_type
+     _DistanceType;
+
+   _Temporary_buffer<_ForwardIterator, _ValueType> __buf(__first,
+        __last);
+ if (__buf.size() > 0)
+   return
+     std::__stable_partition_adaptive(__first, __last, __pred,
+       _DistanceType(__buf.requested_size()),
+       __buf.begin(),
+       _DistanceType(__buf.size()));
+ else
+   return
+     std::__inplace_stable_partition(__first, __last, __pred,
+      _DistanceType(__buf.requested_size()));
+ }
+    }
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __heap_select(_RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last)
+    {
+      std::make_heap(__first, __middle);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+ if (*__i < *__first)
+   std::__pop_heap(__first, __middle, __i);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __heap_select(_RandomAccessIterator __first,
+    _RandomAccessIterator __middle,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      std::make_heap(__first, __middle, __comp);
+      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
+ if (__comp(*__i, *__first))
+   std::__pop_heap(__first, __middle, __i, __comp);
+    }
+# 1938 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator>
+    _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+
+     
+
+     
+      ;
+      ;
+
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while(__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+      std::make_heap(__result_first, __result_real_last);
+      while (__first != __last)
+ {
+   if (*__first < *__result_first)
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first));
+   ++__first;
+ }
+      std::sort_heap(__result_first, __result_real_last);
+      return __result_real_last;
+    }
+# 2004 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _RandomAccessIterator, typename _Compare>
+    _RandomAccessIterator
+    partial_sort_copy(_InputIterator __first, _InputIterator __last,
+        _RandomAccessIterator __result_first,
+        _RandomAccessIterator __result_last,
+        _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator>::value_type
+ _InputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _OutputValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+
+     
+
+     
+
+     
+
+      ;
+      ;
+
+      if (__result_first == __result_last)
+ return __result_last;
+      _RandomAccessIterator __result_real_last = __result_first;
+      while(__first != __last && __result_real_last != __result_last)
+ {
+   *__result_real_last = *__first;
+   ++__result_real_last;
+   ++__first;
+ }
+      std::make_heap(__result_first, __result_real_last, __comp);
+      while (__first != __last)
+ {
+   if (__comp(*__first, *__result_first))
+     std::__adjust_heap(__result_first, _DistanceType(0),
+          _DistanceType(__result_real_last
+          - __result_first),
+          _InputValueType(*__first),
+          __comp);
+   ++__first;
+ }
+      std::sort_heap(__result_first, __result_real_last, __comp);
+      return __result_real_last;
+    }
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+ __val = (*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__val < *__next)
+ {
+   *__last = (*__next);
+   __last = __next;
+   --__next;
+ }
+      *__last = (__val);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __unguarded_linear_insert(_RandomAccessIterator __last,
+         _Compare __comp)
+    {
+      typename iterator_traits<_RandomAccessIterator>::value_type
+ __val = (*__last);
+      _RandomAccessIterator __next = __last;
+      --__next;
+      while (__comp(__val, *__next))
+ {
+   *__last = (*__next);
+   __last = __next;
+   --__next;
+ }
+      *__last = (__val);
+    }
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+       _RandomAccessIterator __last)
+    {
+      if (__first == __last)
+ return;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   if (*__i < *__first)
+     {
+       typename iterator_traits<_RandomAccessIterator>::value_type
+  __val = (*__i);
+       std::copy_backward(__first, __i, __i + 1);
+       *__first = (__val);
+     }
+   else
+     std::__unguarded_linear_insert(__i);
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __insertion_sort(_RandomAccessIterator __first,
+       _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__first == __last) return;
+
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ {
+   if (__comp(*__i, *__first))
+     {
+       typename iterator_traits<_RandomAccessIterator>::value_type
+  __val = (*__i);
+       std::copy_backward(__first, __i, __i + 1);
+       *__first = (__val);
+     }
+   else
+     std::__unguarded_linear_insert(__i, __comp);
+ }
+    }
+
+
+  template<typename _RandomAccessIterator>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    __unguarded_insertion_sort(_RandomAccessIterator __first,
+          _RandomAccessIterator __last, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
+ std::__unguarded_linear_insert(__i, __comp);
+    }
+
+
+
+
+
+  enum { _S_threshold = 16 };
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last)
+    {
+      if (__last - __first > int(_S_threshold))
+ {
+   std::__insertion_sort(__first, __first + int(_S_threshold));
+   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last);
+ }
+      else
+ std::__insertion_sort(__first, __last);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __final_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first > int(_S_threshold))
+ {
+   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
+   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
+       __comp);
+ }
+      else
+ std::__insertion_sort(__first, __last, __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Tp>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last, const _Tp& __pivot)
+    {
+      while (true)
+ {
+   while (*__first < __pivot)
+     ++__first;
+   --__last;
+   while (__pivot < *__last)
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Tp, typename _Compare>
+    _RandomAccessIterator
+    __unguarded_partition(_RandomAccessIterator __first,
+     _RandomAccessIterator __last,
+     const _Tp& __pivot, _Compare __comp)
+    {
+      while (true)
+ {
+   while (__comp(*__first, __pivot))
+     ++__first;
+   --__last;
+   while (__comp(__pivot, *__last))
+     --__last;
+   if (!(__first < __last))
+     return __first;
+   std::iter_swap(__first, __last);
+   ++__first;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_first(__first, __mid, (__last - 1));
+      return std::__unguarded_partition(__first + 1, __last, *__first);
+    }
+
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline _RandomAccessIterator
+    __unguarded_partition_pivot(_RandomAccessIterator __first,
+    _RandomAccessIterator __last, _Compare __comp)
+    {
+      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
+      std::__move_median_first(__first, __mid, (__last - 1), __comp);
+      return std::__unguarded_partition(__first + 1, __last, *__first, __comp);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Size>
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+       _RandomAccessIterator __last,
+       _Size __depth_limit)
+    {
+      while (__last - __first > int(_S_threshold))
+ {
+   if (__depth_limit == 0)
+     {
+       std::partial_sort(__first, __last, __last);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last);
+   std::__introsort_loop(__cut, __last, __depth_limit);
+   __last = __cut;
+ }
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introsort_loop(_RandomAccessIterator __first,
+       _RandomAccessIterator __last,
+       _Size __depth_limit, _Compare __comp)
+    {
+      while (__last - __first > int(_S_threshold))
+ {
+   if (__depth_limit == 0)
+     {
+       std::partial_sort(__first, __last, __last, __comp);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
+   __last = __cut;
+ }
+    }
+
+
+
+  template<typename _RandomAccessIterator, typename _Size>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last);
+
+
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last);
+    }
+
+  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
+    void
+    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+    _RandomAccessIterator __last, _Size __depth_limit,
+    _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+      while (__last - __first > 3)
+ {
+   if (__depth_limit == 0)
+     {
+       std::__heap_select(__first, __nth + 1, __last, __comp);
+
+       std::iter_swap(__first, __nth);
+       return;
+     }
+   --__depth_limit;
+   _RandomAccessIterator __cut =
+     std::__unguarded_partition_pivot(__first, __last, __comp);
+   if (__cut <= __nth)
+     __first = __cut;
+   else
+     __last = __cut;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+# 2388 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+
+     
+                    ;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle;
+
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(*__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else
+     __len = __half;
+ }
+      return __first;
+    }
+# 2437 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+      ;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle;
+
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (__val < *__middle)
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+# 2488 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    _ForwardIterator
+    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+
+     
+                    ;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle;
+
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(__val, *__middle))
+     __len = __half;
+   else
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+ }
+      return __first;
+    }
+# 2543 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+     
+      ;
+      ;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle, __left, __right;
+
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (*__middle < __val)
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__val < *__middle)
+     __len = __half;
+   else
+     {
+       __left = std::lower_bound(__first, __middle, __val);
+       std::advance(__first, __len);
+       __right = std::upper_bound(++__middle, __first, __val);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+# 2605 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    pair<_ForwardIterator, _ForwardIterator>
+    equal_range(_ForwardIterator __first, _ForwardIterator __last,
+  const _Tp& __val,
+  _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_ForwardIterator>::difference_type
+ _DistanceType;
+
+
+     
+     
+
+     
+
+     
+                    ;
+     
+                    ;
+
+      _DistanceType __len = std::distance(__first, __last);
+      _DistanceType __half;
+      _ForwardIterator __middle, __left, __right;
+
+      while (__len > 0)
+ {
+   __half = __len >> 1;
+   __middle = __first;
+   std::advance(__middle, __half);
+   if (__comp(*__middle, __val))
+     {
+       __first = __middle;
+       ++__first;
+       __len = __len - __half - 1;
+     }
+   else if (__comp(__val, *__middle))
+     __len = __half;
+   else
+     {
+       __left = std::lower_bound(__first, __middle, __val, __comp);
+       std::advance(__first, __len);
+       __right = std::upper_bound(++__middle, __first, __val, __comp);
+       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
+     }
+ }
+      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
+    }
+# 2666 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+                  const _Tp& __val)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+     
+     
+      ;
+      ;
+
+      _ForwardIterator __i = std::lower_bound(__first, __last, __val);
+      return __i != __last && !(__val < *__i);
+    }
+# 2699 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp, typename _Compare>
+    bool
+    binary_search(_ForwardIterator __first, _ForwardIterator __last,
+                  const _Tp& __val, _Compare __comp)
+    {
+      typedef typename iterator_traits<_ForwardIterator>::value_type
+ _ValueType;
+
+
+     
+     
+
+     
+                    ;
+     
+                    ;
+
+      _ForwardIterator __i = std::lower_bound(__first, __last, __val, __comp);
+      return __i != __last && !bool(__comp(__val, *__i));
+    }
+
+
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BidirectionalIterator3>
+    _BidirectionalIterator3
+    __merge_backward(_BidirectionalIterator1 __first1,
+       _BidirectionalIterator1 __last1,
+       _BidirectionalIterator2 __first2,
+       _BidirectionalIterator2 __last2,
+       _BidirectionalIterator3 __result)
+    {
+      if (__first1 == __last1)
+ return std::copy_backward(__first2, __last2, __result);
+      if (__first2 == __last2)
+ return std::copy_backward(__first1, __last1, __result);
+      --__last1;
+      --__last2;
+      while (true)
+ {
+   if (*__last2 < *__last1)
+     {
+       *--__result = *__last1;
+       if (__first1 == __last1)
+  return std::copy_backward(__first2, ++__last2, __result);
+       --__last1;
+     }
+   else
+     {
+       *--__result = *__last2;
+       if (__first2 == __last2)
+  return std::copy_backward(__first1, ++__last1, __result);
+       --__last2;
+     }
+ }
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _BidirectionalIterator3, typename _Compare>
+    _BidirectionalIterator3
+    __merge_backward(_BidirectionalIterator1 __first1,
+       _BidirectionalIterator1 __last1,
+       _BidirectionalIterator2 __first2,
+       _BidirectionalIterator2 __last2,
+       _BidirectionalIterator3 __result,
+       _Compare __comp)
+    {
+      if (__first1 == __last1)
+ return std::copy_backward(__first2, __last2, __result);
+      if (__first2 == __last2)
+ return std::copy_backward(__first1, __last1, __result);
+      --__last1;
+      --__last2;
+      while (true)
+ {
+   if (__comp(*__last2, *__last1))
+     {
+       *--__result = *__last1;
+       if (__first1 == __last1)
+  return std::copy_backward(__first2, ++__last2, __result);
+       --__last1;
+     }
+   else
+     {
+       *--__result = *__last2;
+       if (__first2 == __last2)
+  return std::copy_backward(__first1, ++__last1, __result);
+       --__last2;
+     }
+ }
+    }
+
+
+  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
+    typename _Distance>
+    _BidirectionalIterator1
+    __rotate_adaptive(_BidirectionalIterator1 __first,
+        _BidirectionalIterator1 __middle,
+        _BidirectionalIterator1 __last,
+        _Distance __len1, _Distance __len2,
+        _BidirectionalIterator2 __buffer,
+        _Distance __buffer_size)
+    {
+      _BidirectionalIterator2 __buffer_end;
+      if (__len1 > __len2 && __len2 <= __buffer_size)
+ {
+   __buffer_end = std::copy(__middle, __last, __buffer);
+   std::copy_backward(__first, __middle, __last);
+   return std::copy(__buffer, __buffer_end, __first);
+ }
+      else if (__len1 <= __buffer_size)
+ {
+   __buffer_end = std::copy(__first, __middle, __buffer);
+   std::copy(__middle, __last, __first);
+   return std::copy_backward(__buffer, __buffer_end, __last);
+ }
+      else
+ {
+   std::rotate(__first, __middle, __last);
+   std::advance(__first, std::distance(__middle, __last));
+   return __first;
+ }
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Pointer>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+                     _BidirectionalIterator __middle,
+       _BidirectionalIterator __last,
+       _Distance __len1, _Distance __len2,
+       _Pointer __buffer, _Distance __buffer_size)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
+   std::merge((__buffer),
+    (__buffer_end),
+    (__middle),
+    (__last),
+    __first);
+ }
+      else if (__len2 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
+   std::__merge_backward((__first),
+    (__middle),
+    (__buffer),
+    (__buffer_end),
+    __last);
+ }
+      else
+ {
+   _BidirectionalIterator __first_cut = __first;
+   _BidirectionalIterator __second_cut = __middle;
+   _Distance __len11 = 0;
+   _Distance __len22 = 0;
+   if (__len1 > __len2)
+     {
+       __len11 = __len1 / 2;
+       std::advance(__first_cut, __len11);
+       __second_cut = std::lower_bound(__middle, __last,
+           *__first_cut);
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut = std::upper_bound(__first, __middle,
+          *__second_cut);
+       __len11 = std::distance(__first, __first_cut);
+     }
+   _BidirectionalIterator __new_middle =
+     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+       __len1 - __len11, __len22, __buffer,
+       __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer, __buffer_size);
+ }
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Pointer, typename _Compare>
+    void
+    __merge_adaptive(_BidirectionalIterator __first,
+                     _BidirectionalIterator __middle,
+       _BidirectionalIterator __last,
+       _Distance __len1, _Distance __len2,
+       _Pointer __buffer, _Distance __buffer_size,
+       _Compare __comp)
+    {
+      if (__len1 <= __len2 && __len1 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__first, __middle, __buffer);
+   std::merge((__buffer),
+    (__buffer_end),
+    (__middle),
+    (__last),
+    __first, __comp);
+ }
+      else if (__len2 <= __buffer_size)
+ {
+   _Pointer __buffer_end = std::copy(__middle, __last, __buffer);
+   std::__merge_backward((__first),
+    (__middle),
+    (__buffer),
+    (__buffer_end),
+    __last,__comp);
+ }
+      else
+ {
+   _BidirectionalIterator __first_cut = __first;
+   _BidirectionalIterator __second_cut = __middle;
+   _Distance __len11 = 0;
+   _Distance __len22 = 0;
+   if (__len1 > __len2)
+     {
+       __len11 = __len1 / 2;
+       std::advance(__first_cut, __len11);
+       __second_cut = std::lower_bound(__middle, __last, *__first_cut,
+           __comp);
+       __len22 = std::distance(__middle, __second_cut);
+     }
+   else
+     {
+       __len22 = __len2 / 2;
+       std::advance(__second_cut, __len22);
+       __first_cut = std::upper_bound(__first, __middle, *__second_cut,
+          __comp);
+       __len11 = std::distance(__first, __first_cut);
+     }
+   _BidirectionalIterator __new_middle =
+     std::__rotate_adaptive(__first_cut, __middle, __second_cut,
+       __len1 - __len11, __len22, __buffer,
+       __buffer_size);
+   std::__merge_adaptive(__first, __first_cut, __new_middle, __len11,
+    __len22, __buffer, __buffer_size, __comp);
+   std::__merge_adaptive(__new_middle, __second_cut, __last,
+    __len1 - __len11,
+    __len2 - __len22, __buffer,
+    __buffer_size, __comp);
+ }
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+      _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Distance __len1, _Distance __len2)
+    {
+      if (__len1 == 0 || __len2 == 0)
+ return;
+      if (__len1 + __len2 == 2)
+ {
+   if (*__middle < *__first)
+     std::iter_swap(__first, __middle);
+   return;
+ }
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+ {
+   __len11 = __len1 / 2;
+   std::advance(__first_cut, __len11);
+   __second_cut = std::lower_bound(__middle, __last, *__first_cut);
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut = std::upper_bound(__first, __middle, *__second_cut);
+   __len11 = std::distance(__first, __first_cut);
+ }
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22);
+    }
+
+
+  template<typename _BidirectionalIterator, typename _Distance,
+    typename _Compare>
+    void
+    __merge_without_buffer(_BidirectionalIterator __first,
+                           _BidirectionalIterator __middle,
+      _BidirectionalIterator __last,
+      _Distance __len1, _Distance __len2,
+      _Compare __comp)
+    {
+      if (__len1 == 0 || __len2 == 0)
+ return;
+      if (__len1 + __len2 == 2)
+ {
+   if (__comp(*__middle, *__first))
+     std::iter_swap(__first, __middle);
+   return;
+ }
+      _BidirectionalIterator __first_cut = __first;
+      _BidirectionalIterator __second_cut = __middle;
+      _Distance __len11 = 0;
+      _Distance __len22 = 0;
+      if (__len1 > __len2)
+ {
+   __len11 = __len1 / 2;
+   std::advance(__first_cut, __len11);
+   __second_cut = std::lower_bound(__middle, __last, *__first_cut,
+       __comp);
+   __len22 = std::distance(__middle, __second_cut);
+ }
+      else
+ {
+   __len22 = __len2 / 2;
+   std::advance(__second_cut, __len22);
+   __first_cut = std::upper_bound(__first, __middle, *__second_cut,
+      __comp);
+   __len11 = std::distance(__first, __first_cut);
+ }
+      std::rotate(__first_cut, __middle, __second_cut);
+      _BidirectionalIterator __new_middle = __first_cut;
+      std::advance(__new_middle, std::distance(__middle, __second_cut));
+      std::__merge_without_buffer(__first, __first_cut, __new_middle,
+      __len11, __len22, __comp);
+      std::__merge_without_buffer(__new_middle, __second_cut, __last,
+      __len1 - __len11, __len2 - __len22, __comp);
+    }
+# 3059 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+          _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+          _DistanceType;
+
+
+     
+
+     
+      ;
+      ;
+
+      if (__first == __middle || __middle == __last)
+ return;
+
+      _DistanceType __len1 = std::distance(__first, __middle);
+      _DistanceType __len2 = std::distance(__middle, __last);
+
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
+          __last);
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer(__first, __middle, __last, __len1, __len2);
+      else
+ std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
+         __buf.begin(), _DistanceType(__buf.size()));
+    }
+# 3114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    void
+    inplace_merge(_BidirectionalIterator __first,
+    _BidirectionalIterator __middle,
+    _BidirectionalIterator __last,
+    _Compare __comp)
+    {
+      typedef typename iterator_traits<_BidirectionalIterator>::value_type
+          _ValueType;
+      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
+          _DistanceType;
+
+
+     
+
+     
+
+      ;
+      ;
+
+      if (__first == __middle || __middle == __last)
+ return;
+
+      const _DistanceType __len1 = std::distance(__first, __middle);
+      const _DistanceType __len2 = std::distance(__middle, __last);
+
+      _Temporary_buffer<_BidirectionalIterator, _ValueType> __buf(__first,
+          __last);
+      if (__buf.begin() == 0)
+ std::__merge_without_buffer(__first, __middle, __last, __len1,
+        __len2, __comp);
+      else
+ std::__merge_adaptive(__first, __middle, __last, __len1, __len2,
+         __buf.begin(), _DistanceType(__buf.size()),
+         __comp);
+    }
+
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+    typename _Distance>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+        _RandomAccessIterator1 __last,
+        _RandomAccessIterator2 __result,
+        _Distance __step_size)
+    {
+      const _Distance __two_step = 2 * __step_size;
+
+      while (__last - __first >= __two_step)
+ {
+   __result = std::merge(
+   (__first),
+   (__first + __step_size),
+   (__first + __step_size),
+   (__first + __two_step),
+   __result);
+   __first += __two_step;
+ }
+
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+      std::merge((__first),
+       (__first + __step_size)
+                   ,
+       (__first + __step_size)
+                   ,
+       (__last),
+       __result);
+    }
+
+  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
+    typename _Distance, typename _Compare>
+    void
+    __merge_sort_loop(_RandomAccessIterator1 __first,
+        _RandomAccessIterator1 __last,
+        _RandomAccessIterator2 __result, _Distance __step_size,
+        _Compare __comp)
+    {
+      const _Distance __two_step = 2 * __step_size;
+
+      while (__last - __first >= __two_step)
+ {
+   __result = std::merge(
+   (__first),
+   (__first + __step_size),
+   (__first + __step_size),
+   (__first + __two_step),
+   __result, __comp);
+   __first += __two_step;
+ }
+      __step_size = std::min(_Distance(__last - __first), __step_size);
+
+      std::merge((__first),
+       (__first + __step_size)
+                   ,
+       (__first + __step_size)
+                   ,
+       (__last),
+       __result, __comp);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance>
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Distance __chunk_size)
+    {
+      while (__last - __first >= __chunk_size)
+ {
+   std::__insertion_sort(__first, __first + __chunk_size);
+   __first += __chunk_size;
+ }
+      std::__insertion_sort(__first, __last);
+    }
+
+  template<typename _RandomAccessIterator, typename _Distance,
+    typename _Compare>
+    void
+    __chunk_insertion_sort(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+      _Distance __chunk_size, _Compare __comp)
+    {
+      while (__last - __first >= __chunk_size)
+ {
+   std::__insertion_sort(__first, __first + __chunk_size, __comp);
+   __first += __chunk_size;
+ }
+      std::__insertion_sort(__first, __last, __comp);
+    }
+
+  enum { _S_chunk_size = 7 };
+
+  template<typename _RandomAccessIterator, typename _Pointer>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+        _RandomAccessIterator __last,
+                             _Pointer __buffer)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size);
+
+      while (__step_size < __len)
+ {
+   std::__merge_sort_loop(__first, __last, __buffer, __step_size);
+   __step_size *= 2;
+   std::__merge_sort_loop(__buffer, __buffer_last, __first, __step_size);
+   __step_size *= 2;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
+    void
+    __merge_sort_with_buffer(_RandomAccessIterator __first,
+        _RandomAccessIterator __last,
+                             _Pointer __buffer, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _Distance;
+
+      const _Distance __len = __last - __first;
+      const _Pointer __buffer_last = __buffer + __len;
+
+      _Distance __step_size = _S_chunk_size;
+      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);
+
+      while (__step_size < __len)
+ {
+   std::__merge_sort_loop(__first, __last, __buffer,
+     __step_size, __comp);
+   __step_size *= 2;
+   std::__merge_sort_loop(__buffer, __buffer_last, __first,
+     __step_size, __comp);
+   __step_size *= 2;
+ }
+    }
+
+  template<typename _RandomAccessIterator, typename _Pointer,
+    typename _Distance>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+                           _Pointer __buffer, _Distance __buffer_size)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+ {
+   std::__stable_sort_adaptive(__first, __middle,
+          __buffer, __buffer_size);
+   std::__stable_sort_adaptive(__middle, __last,
+          __buffer, __buffer_size);
+ }
+      else
+ {
+   std::__merge_sort_with_buffer(__first, __middle, __buffer);
+   std::__merge_sort_with_buffer(__middle, __last, __buffer);
+ }
+      std::__merge_adaptive(__first, __middle, __last,
+       _Distance(__middle - __first),
+       _Distance(__last - __middle),
+       __buffer, __buffer_size);
+    }
+
+  template<typename _RandomAccessIterator, typename _Pointer,
+    typename _Distance, typename _Compare>
+    void
+    __stable_sort_adaptive(_RandomAccessIterator __first,
+      _RandomAccessIterator __last,
+                           _Pointer __buffer, _Distance __buffer_size,
+                           _Compare __comp)
+    {
+      const _Distance __len = (__last - __first + 1) / 2;
+      const _RandomAccessIterator __middle = __first + __len;
+      if (__len > __buffer_size)
+ {
+   std::__stable_sort_adaptive(__first, __middle, __buffer,
+          __buffer_size, __comp);
+   std::__stable_sort_adaptive(__middle, __last, __buffer,
+          __buffer_size, __comp);
+ }
+      else
+ {
+   std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
+   std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);
+ }
+      std::__merge_adaptive(__first, __middle, __last,
+       _Distance(__middle - __first),
+       _Distance(__last - __middle),
+       __buffer, __buffer_size,
+       __comp);
+    }
+
+
+  template<typename _RandomAccessIterator>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __last)
+    {
+      if (__last - __first < 15)
+ {
+   std::__insertion_sort(__first, __last);
+   return;
+ }
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle);
+      std::__inplace_stable_sort(__middle, __last);
+      std::__merge_without_buffer(__first, __middle, __last,
+      __middle - __first,
+      __last - __middle);
+    }
+
+
+  template<typename _RandomAccessIterator, typename _Compare>
+    void
+    __inplace_stable_sort(_RandomAccessIterator __first,
+     _RandomAccessIterator __last, _Compare __comp)
+    {
+      if (__last - __first < 15)
+ {
+   std::__insertion_sort(__first, __last, __comp);
+   return;
+ }
+      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
+      std::__inplace_stable_sort(__first, __middle, __comp);
+      std::__inplace_stable_sort(__middle, __last, __comp);
+      std::__merge_without_buffer(__first, __middle, __last,
+      __middle - __first,
+      __last - __middle,
+      __comp);
+    }
+# 3412 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2>
+    bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+     
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first2 < *__first1)
+   return false;
+ else if(*__first1 < *__first2)
+   ++__first1;
+ else
+   ++__first1, ++__first2;
+
+      return __first2 == __last2;
+    }
+# 3461 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _Compare>
+    bool
+    includes(_InputIterator1 __first1, _InputIterator1 __last1,
+      _InputIterator2 __first2, _InputIterator2 __last2,
+      _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first2, *__first1))
+   return false;
+ else if(__comp(*__first1, *__first2))
+   ++__first1;
+ else
+   ++__first1, ++__first2;
+
+      return __first2 == __last2;
+    }
+# 3516 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (*__i < *__ii)
+     {
+       _BidirectionalIterator __j = __last;
+       while (!(*__i < *--__j))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+# 3573 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    next_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(*__i, *__ii))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!bool(__comp(*__i, *--__j)))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+# 3629 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator>
+    bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last)
+    {
+
+     
+
+     
+
+      ;
+
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (*__ii < *__i)
+     {
+       _BidirectionalIterator __j = __last;
+       while (!(*--__j < *__i))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+# 3686 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _BidirectionalIterator, typename _Compare>
+    bool
+    prev_permutation(_BidirectionalIterator __first,
+       _BidirectionalIterator __last, _Compare __comp)
+    {
+
+     
+
+     
+
+
+      ;
+
+      if (__first == __last)
+ return false;
+      _BidirectionalIterator __i = __first;
+      ++__i;
+      if (__i == __last)
+ return false;
+      __i = __last;
+      --__i;
+
+      for(;;)
+ {
+   _BidirectionalIterator __ii = __i;
+   --__i;
+   if (__comp(*__ii, *__i))
+     {
+       _BidirectionalIterator __j = __last;
+       while (!bool(__comp(*--__j, *__i)))
+  {}
+       std::iter_swap(__i, __j);
+       std::reverse(__ii, __last);
+       return true;
+     }
+   if (__i == __first)
+     {
+       std::reverse(__first, __last);
+       return false;
+     }
+ }
+    }
+# 3746 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
+    _OutputIterator
+    replace_copy(_InputIterator __first, _InputIterator __last,
+   _OutputIterator __result,
+   const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first, ++__result)
+ if (*__first == __old_value)
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+# 3783 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _Predicate, typename _Tp>
+    _OutputIterator
+    replace_copy_if(_InputIterator __first, _InputIterator __last,
+      _OutputIterator __result,
+      _Predicate __pred, const _Tp& __new_value)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first, ++__result)
+ if (__pred(*__first))
+   *__result = __new_value;
+ else
+   *__result = *__first;
+      return __result;
+    }
+# 4161 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+}
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 4177 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Function>
+    _Function
+    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
+    {
+
+     
+      ;
+      for (; __first != __last; ++__first)
+ __f(*__first);
+      return (__f);
+    }
+# 4198 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+    inline _InputIterator
+    find(_InputIterator __first, _InputIterator __last,
+  const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+      return std::__find(__first, __last, __val,
+           std::__iterator_category(__first));
+    }
+# 4222 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    inline _InputIterator
+    find_if(_InputIterator __first, _InputIterator __last,
+     _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+      return std::__find_if(__first, __last, __pred,
+       std::__iterator_category(__first));
+    }
+# 4251 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (*__first1 == *__iter)
+     return __first1;
+      return __last1;
+    }
+# 4290 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _ForwardIterator,
+    typename _BinaryPredicate>
+    _InputIterator
+    find_first_of(_InputIterator __first1, _InputIterator __last1,
+    _ForwardIterator __first2, _ForwardIterator __last2,
+    _BinaryPredicate __comp)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+      for (; __first1 != __last1; ++__first1)
+ for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
+   if (__comp(*__first1, *__iter))
+     return __first1;
+      return __last1;
+    }
+# 4322 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      while(++__next != __last)
+ {
+   if (*__first == *__next)
+     return __first;
+   __first = __next;
+ }
+      return __last;
+    }
+# 4354 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _BinaryPredicate>
+    _ForwardIterator
+    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
+    _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+
+      ;
+      if (__first == __last)
+ return __last;
+      _ForwardIterator __next = __first;
+      while(++__next != __last)
+ {
+   if (__binary_pred(*__first, *__next))
+     return __first;
+   __first = __next;
+ }
+      return __last;
+    }
+# 4386 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Tp>
+    typename iterator_traits<_InputIterator>::difference_type
+    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
+    {
+
+     
+     
+
+      ;
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+ if (*__first == __value)
+   ++__n;
+      return __n;
+    }
+# 4411 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _Predicate>
+    typename iterator_traits<_InputIterator>::difference_type
+    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
+    {
+
+     
+     
+
+      ;
+      typename iterator_traits<_InputIterator>::difference_type __n = 0;
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   ++__n;
+      return __n;
+    }
+# 4451 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2>
+    _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+
+
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ return std::find(__first1, __last1, *__first2);
+
+
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+
+      for (;;)
+ {
+   __first1 = std::find(__first1, __last1, *__first2);
+   if (__first1 == __last1)
+     return __last1;
+
+   __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+
+   while (*__current == *__p)
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+# 4522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator1, typename _ForwardIterator2,
+    typename _BinaryPredicate>
+    _ForwardIterator1
+    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
+    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
+    _BinaryPredicate __predicate)
+    {
+
+     
+     
+     
+
+
+      ;
+      ;
+
+
+      if (__first1 == __last1 || __first2 == __last2)
+ return __first1;
+
+
+      _ForwardIterator2 __p1(__first2);
+      if (++__p1 == __last2)
+ {
+   while (__first1 != __last1
+   && !bool(__predicate(*__first1, *__first2)))
+     ++__first1;
+   return __first1;
+ }
+
+
+      _ForwardIterator2 __p;
+      _ForwardIterator1 __current = __first1;
+
+      for (;;)
+ {
+   while (__first1 != __last1
+   && !bool(__predicate(*__first1, *__first2)))
+     ++__first1;
+   if (__first1 == __last1)
+     return __last1;
+
+   __p = __p1;
+   __current = __first1;
+   if (++__current == __last1)
+     return __last1;
+
+   while (__predicate(*__current, *__p))
+     {
+       if (++__p == __last2)
+  return __first1;
+       if (++__current == __last1)
+  return __last1;
+     }
+   ++__first1;
+ }
+      return __first1;
+    }
+# 4596 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp>
+    _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val)
+    {
+
+     
+     
+
+      ;
+
+      if (__count <= 0)
+ return __first;
+      if (__count == 1)
+ return std::find(__first, __last, __val);
+      return std::__search_n(__first, __last, __count, __val,
+        std::__iterator_category(__first));
+    }
+# 4632 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Integer, typename _Tp,
+           typename _BinaryPredicate>
+    _ForwardIterator
+    search_n(_ForwardIterator __first, _ForwardIterator __last,
+      _Integer __count, const _Tp& __val,
+      _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+      ;
+
+      if (__count <= 0)
+ return __first;
+      if (__count == 1)
+ {
+   while (__first != __last && !bool(__binary_pred(*__first, __val)))
+     ++__first;
+   return __first;
+ }
+      return std::__search_n(__first, __last, __count, __val, __binary_pred,
+        std::__iterator_category(__first));
+    }
+# 4674 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _UnaryOperation>
+    _OutputIterator
+    transform(_InputIterator __first, _InputIterator __last,
+       _OutputIterator __result, _UnaryOperation __unary_op)
+    {
+
+     
+     
+
+
+      ;
+
+      for (; __first != __last; ++__first, ++__result)
+ *__result = __unary_op(*__first);
+      return __result;
+    }
+# 4710 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _BinaryOperation>
+    _OutputIterator
+    transform(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _OutputIterator __result,
+       _BinaryOperation __binary_op)
+    {
+
+     
+     
+     
+
+
+      ;
+
+      for (; __first1 != __last1; ++__first1, ++__first2, ++__result)
+ *__result = __binary_op(*__first1, *__first2);
+      return __result;
+    }
+# 4743 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Tp>
+    void
+    replace(_ForwardIterator __first, _ForwardIterator __last,
+     const _Tp& __old_value, const _Tp& __new_value)
+    {
+
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (*__first == __old_value)
+   *__first = __new_value;
+    }
+# 4775 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
+    void
+    replace_if(_ForwardIterator __first, _ForwardIterator __last,
+        _Predicate __pred, const _Tp& __new_value)
+    {
+
+     
+
+     
+
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ if (__pred(*__first))
+   *__first = __new_value;
+    }
+# 4807 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Generator>
+    void
+    generate(_ForwardIterator __first, _ForwardIterator __last,
+      _Generator __gen)
+    {
+
+     
+     
+
+      ;
+
+      for (; __first != __last; ++__first)
+ *__first = __gen();
+    }
+# 4838 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _OutputIterator, typename _Size, typename _Generator>
+    _OutputIterator
+    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
+    {
+
+     
+
+
+
+      for (; __n > 0; --__n, ++__first)
+ *__first = __gen();
+      return __first;
+    }
+# 4874 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result)
+    {
+
+     
+     
+
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result,
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4913 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator, typename _OutputIterator,
+    typename _BinaryPredicate>
+    inline _OutputIterator
+    unique_copy(_InputIterator __first, _InputIterator __last,
+  _OutputIterator __result,
+  _BinaryPredicate __binary_pred)
+    {
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __result;
+      return std::__unique_copy(__first, __last, __result, __binary_pred,
+    std::__iterator_category(__first),
+    std::__iterator_category(__result));
+    }
+# 4945 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+
+     
+
+      ;
+
+      if (__first != __last)
+ for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+   std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));
+    }
+# 4973 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
+    void
+    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
+
+
+
+     _RandomNumberGenerator& __rand)
+
+    {
+
+     
+
+      ;
+
+      if (__first == __last)
+ return;
+      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
+ std::iter_swap(__i, __first + __rand((__i - __first) + 1));
+    }
+# 5009 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Predicate>
+    inline _ForwardIterator
+    partition(_ForwardIterator __first, _ForwardIterator __last,
+       _Predicate __pred)
+    {
+
+     
+
+     
+
+      ;
+
+      return std::__partition(__first, __last, __pred,
+         std::__iterator_category(__first));
+    }
+# 5043 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+      ;
+      ;
+
+      std::__heap_select(__first, __middle, __last);
+      std::sort_heap(__first, __middle);
+    }
+# 5082 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    partial_sort(_RandomAccessIterator __first,
+   _RandomAccessIterator __middle,
+   _RandomAccessIterator __last,
+   _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+
+      ;
+      ;
+
+      std::__heap_select(__first, __middle, __last, __comp);
+      std::sort_heap(__first, __middle, __comp);
+    }
+# 5120 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+      ;
+      ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2);
+    }
+# 5159 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth,
+  _RandomAccessIterator __last, _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+
+      ;
+      ;
+
+      if (__first == __last || __nth == __last)
+ return;
+
+      std::__introselect(__first, __nth, __last,
+    std::__lg(__last - __first) * 2, __comp);
+    }
+# 5197 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+      ;
+
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2);
+   std::__final_insertion_sort(__first, __last);
+ }
+    }
+# 5233 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+
+
+     
+
+     
+
+      ;
+
+      if (__first != __last)
+ {
+   std::__introsort_loop(__first, __last,
+    std::__lg(__last - __first) * 2, __comp);
+   std::__final_insertion_sort(__first, __last, __comp);
+ }
+    }
+# 5274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (*__first2 < *__first1)
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+# 5337 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    merge(_InputIterator1 __first1, _InputIterator1 __last1,
+   _InputIterator2 __first2, _InputIterator2 __last2,
+   _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(*__first2, *__first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+# 5397 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+
+     
+
+     
+      ;
+
+      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
+         __last);
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()));
+    }
+# 5439 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _RandomAccessIterator, typename _Compare>
+    inline void
+    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
+  _Compare __comp)
+    {
+      typedef typename iterator_traits<_RandomAccessIterator>::value_type
+ _ValueType;
+      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
+ _DistanceType;
+
+
+     
+
+     
+
+
+      ;
+
+      _Temporary_buffer<_RandomAccessIterator, _ValueType> __buf(__first,
+         __last);
+      if (__buf.begin() == 0)
+ std::__inplace_stable_sort(__first, __last, __comp);
+      else
+ std::__stable_sort_adaptive(__first, __last, __buf.begin(),
+        _DistanceType(__buf.size()), __comp);
+    }
+# 5485 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+     
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (*__first1 < *__first2)
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (*__first2 < *__first1)
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+# 5552 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+
+     
+
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ {
+   if (__comp(*__first1, *__first2))
+     {
+       *__result = *__first1;
+       ++__first1;
+     }
+   else if (__comp(*__first2, *__first1))
+     {
+       *__result = *__first2;
+       ++__first2;
+     }
+   else
+     {
+       *__result = *__first1;
+       ++__first1;
+       ++__first2;
+     }
+   ++__result;
+ }
+      return std::copy(__first2, __last2, std::copy(__first1, __last1,
+          __result));
+    }
+# 5619 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+     
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first1 < *__first2)
+   ++__first1;
+ else if (*__first2 < *__first1)
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+# 5676 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
+       _InputIterator2 __first2, _InputIterator2 __last2,
+       _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2))
+   ++__first1;
+ else if (__comp(*__first2, *__first1))
+   ++__first2;
+ else
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__first2;
+     ++__result;
+   }
+      return __result;
+    }
+# 5734 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+     
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first1 < *__first2)
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (*__first2 < *__first1)
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+# 5795 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+     _InputIterator2 __first2, _InputIterator2 __last2,
+     _OutputIterator __result, _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(*__first2, *__first1))
+   ++__first2;
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first1, __last1, __result);
+    }
+# 5853 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator>
+    _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+     
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (*__first1 < *__first2)
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (*__first2 < *__first1)
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2, std::copy(__first1,
+          __last1, __result));
+    }
+# 5919 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _InputIterator1, typename _InputIterator2,
+    typename _OutputIterator, typename _Compare>
+    _OutputIterator
+    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
+        _InputIterator2 __first2, _InputIterator2 __last2,
+        _OutputIterator __result,
+        _Compare __comp)
+    {
+      typedef typename iterator_traits<_InputIterator1>::value_type
+ _ValueType1;
+      typedef typename iterator_traits<_InputIterator2>::value_type
+ _ValueType2;
+
+
+     
+     
+     
+
+     
+
+     
+
+     
+
+      ;
+      ;
+
+      while (__first1 != __last1 && __first2 != __last2)
+ if (__comp(*__first1, *__first2))
+   {
+     *__result = *__first1;
+     ++__first1;
+     ++__result;
+   }
+ else if (__comp(*__first2, *__first1))
+   {
+     *__result = *__first2;
+     ++__first2;
+     ++__result;
+   }
+ else
+   {
+     ++__first1;
+     ++__first2;
+   }
+      return std::copy(__first2, __last2,
+         std::copy(__first1, __last1, __result));
+    }
+# 5976 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (*__first < *__result)
+   __result = __first;
+      return __result;
+    }
+# 6004 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    min_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(*__first, *__result))
+   __result = __first;
+      return __result;
+    }
+# 6032 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator>
+    _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last)
+    {
+
+     
+     
+
+      ;
+
+      if (__first == __last)
+ return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (*__result < *__first)
+   __result = __first;
+      return __result;
+    }
+# 6060 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_algo.h" 3
+  template<typename _ForwardIterator, typename _Compare>
+    _ForwardIterator
+    max_element(_ForwardIterator __first, _ForwardIterator __last,
+  _Compare __comp)
+    {
+
+     
+     
+
+
+      ;
+
+      if (__first == __last) return __first;
+      _ForwardIterator __result = __first;
+      while (++__first != __last)
+ if (__comp(*__result, *__first))
+   __result = __first;
+      return __result;
+    }
+
+}
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/algorithm" 2 3
+# 14 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/config/no_tr1/functional.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/config/no_tr1/functional.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/functional" 1 3
+# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/functional" 3
+       
+# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/functional" 3
+# 22 "/usr/include/boost-1_42/boost/config/no_tr1/functional.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/throw_exception.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/throw_exception.hpp"
+# 1 "/usr/include/boost-1_42/boost/exception/detail/attribute_noreturn.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/throw_exception.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/throw_exception.hpp"
+# 1 "/usr/include/boost-1_42/boost/exception/exception.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/exception/exception.hpp"
+       
+# 10 "/usr/include/boost-1_42/boost/exception/exception.hpp" 3
+
+
+
+
+
+namespace
+boost
+    {
+    namespace
+    exception_detail
+        {
+        template <class T>
+        class
+        refcount_ptr
+            {
+            public:
+
+            refcount_ptr():
+                px_(0)
+                {
+                }
+
+            ~refcount_ptr()
+                {
+                release();
+                }
+
+            refcount_ptr( refcount_ptr const & x ):
+                px_(x.px_)
+                {
+                add_ref();
+                }
+
+            refcount_ptr &
+            operator=( refcount_ptr const & x )
+                {
+                adopt(x.px_);
+                return *this;
+                }
+
+            void
+            adopt( T * px )
+                {
+                release();
+                px_=px;
+                add_ref();
+                }
+
+            T *
+            get() const
+                {
+                return px_;
+                }
+
+            private:
+
+            T * px_;
+
+            void
+            add_ref()
+                {
+                if( px_ )
+                    px_->add_ref();
+                }
+
+            void
+            release()
+                {
+                if( px_ )
+                    px_->release();
+                }
+            };
+        }
+
+
+
+    template <class Tag,class T>
+    class error_info;
+
+    typedef error_info<struct throw_function_,char const *> throw_function;
+    typedef error_info<struct throw_file_,char const *> throw_file;
+    typedef error_info<struct throw_line_,int> throw_line;
+
+    template <>
+    class
+    error_info<throw_function_,char const *>
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    template <>
+    class
+    error_info<throw_file_,char const *>
+        {
+        public:
+        typedef char const * value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    template <>
+    class
+    error_info<throw_line_,int>
+        {
+        public:
+        typedef int value_type;
+        value_type v_;
+        explicit
+        error_info( value_type v ):
+            v_(v)
+            {
+            }
+        };
+
+    template <class E,class Tag,class T>
+    E const & operator<<( E const &, error_info<Tag,T> const & );
+
+    template <class E>
+    E const & operator<<( E const &, throw_function const & );
+
+    template <class E>
+    E const & operator<<( E const &, throw_file const & );
+
+    template <class E>
+    E const & operator<<( E const &, throw_line const & );
+
+    class exception;
+
+    template <class>
+    class shared_ptr;
+
+    namespace
+    exception_detail
+        {
+        class error_info_base;
+        struct type_info_;
+
+        struct
+        error_info_container
+            {
+            virtual char const * diagnostic_information( char const * ) const = 0;
+            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
+            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
+            virtual void add_ref() const = 0;
+            virtual void release() const = 0;
+
+            protected:
+
+            ~error_info_container() throw()
+                {
+                }
+            };
+
+        template <class>
+        struct get_info;
+
+        template <>
+        struct get_info<throw_function>;
+
+        template <>
+        struct get_info<throw_file>;
+
+        template <>
+        struct get_info<throw_line>;
+
+        char const * get_diagnostic_information( exception const &, char const * );
+        }
+
+    class
+    exception
+        {
+        protected:
+
+        exception():
+            throw_function_(0),
+            throw_file_(0),
+            throw_line_(-1)
+            {
+            }
+# 213 "/usr/include/boost-1_42/boost/exception/exception.hpp" 3
+        virtual ~exception() throw()
+
+            = 0
+
+            ;
+
+
+
+
+        private:
+
+        template <class E>
+        friend E const & operator<<( E const &, throw_function const & );
+
+        template <class E>
+        friend E const & operator<<( E const &, throw_file const & );
+
+        template <class E>
+        friend E const & operator<<( E const &, throw_line const & );
+
+        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );
+
+        template <class E,class Tag,class T>
+        friend E const & operator<<( E const &, error_info<Tag,T> const & );
+
+        template <class>
+        friend struct exception_detail::get_info;
+        friend struct exception_detail::get_info<throw_function>;
+        friend struct exception_detail::get_info<throw_file>;
+        friend struct exception_detail::get_info<throw_line>;
+
+        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
+        mutable char const * throw_function_;
+        mutable char const * throw_file_;
+        mutable int throw_line_;
+        };
+
+    inline
+    exception::
+    ~exception() throw()
+        {
+        }
+
+    template <class E>
+    E const &
+    operator<<( E const & x, throw_function const & y )
+        {
+        x.throw_function_=y.v_;
+        return x;
+        }
+
+    template <class E>
+    E const &
+    operator<<( E const & x, throw_file const & y )
+        {
+        x.throw_file_=y.v_;
+        return x;
+        }
+
+    template <class E>
+    E const &
+    operator<<( E const & x, throw_line const & y )
+        {
+        x.throw_line_=y.v_;
+        return x;
+        }
+
+
+
+    namespace
+    exception_detail
+        {
+        template <class T>
+        struct
+        error_info_injector:
+            public T,
+            public exception
+            {
+            explicit
+            error_info_injector( T const & x ):
+                T(x)
+                {
+                }
+
+            ~error_info_injector() throw()
+                {
+                }
+            };
+
+        struct large_size { char c[256]; };
+        large_size dispatch( exception * );
+
+        struct small_size { };
+        small_size dispatch( void * );
+
+        template <class,int>
+        struct enable_error_info_helper;
+
+        template <class T>
+        struct
+        enable_error_info_helper<T,sizeof(large_size)>
+            {
+            typedef T type;
+            };
+
+        template <class T>
+        struct
+        enable_error_info_helper<T,sizeof(small_size)>
+            {
+            typedef error_info_injector<T> type;
+            };
+
+        template <class T>
+        struct
+        enable_error_info_return_type
+            {
+            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch((T*)0))>::type type;
+            };
+        }
+
+    template <class T>
+    inline
+    typename
+    exception_detail::enable_error_info_return_type<T>::type
+    enable_error_info( T const & x )
+        {
+        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
+        return rt(x);
+        }
+
+
+
+    namespace
+    exception_detail
+        {
+        class
+        clone_base
+            {
+            public:
+
+            virtual clone_base const * clone() const = 0;
+            virtual void rethrow() const = 0;
+
+            virtual
+            ~clone_base() throw()
+                {
+                }
+            };
+
+        inline
+        void
+        copy_boost_exception( exception * a, exception const * b )
+            {
+            *a = *b;
+            }
+
+        inline
+        void
+        copy_boost_exception( void *, void const * )
+            {
+            }
+
+        template <class T>
+        class
+        clone_impl:
+            public T,
+            public clone_base
+            {
+            public:
+
+            explicit
+            clone_impl( T const & x ):
+                T(x)
+                {
+                copy_boost_exception(this,&x);
+                }
+
+            ~clone_impl() throw()
+                {
+                }
+
+            private:
+
+            clone_base const *
+            clone() const
+                {
+                return new clone_impl(*this);
+                }
+
+            void
+            rethrow() const
+                {
+                throw*this;
+                }
+            };
+        }
+
+    template <class T>
+    inline
+    exception_detail::clone_impl<T>
+    enable_current_exception( T const & x )
+        {
+        return exception_detail::clone_impl<T>(x);
+        }
+    }
+# 38 "/usr/include/boost-1_42/boost/throw_exception.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/current_function.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/current_function.hpp"
+namespace boost
+{
+
+namespace detail
+{
+
+inline void current_function_helper()
+{
+# 61 "/usr/include/boost-1_42/boost/current_function.hpp"
+}
+
+}
+
+}
+# 39 "/usr/include/boost-1_42/boost/throw_exception.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/throw_exception.hpp"
+namespace boost
+{
+
+
+
+
+
+
+
+inline void throw_exception_assert_compatibility( std::exception const & ) { }
+
+template<class E> __attribute__((noreturn)) inline void throw_exception( E const & e )
+{
+
+
+    throw_exception_assert_compatibility(e);
+
+
+    throw enable_current_exception(enable_error_info(e));
+
+
+
+}
+
+
+
+}
+# 16 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/function/function_base.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/function/function_base.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 1 3
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 3
+       
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 53 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/stdexcept" 3
+  class logic_error : public exception
+  {
+    string _M_msg;
+
+  public:
+
+    explicit
+    logic_error(const string& __arg);
+
+    virtual
+    ~logic_error() throw();
+
+
+
+    virtual const char*
+    what() const throw();
+  };
+
+
+
+  class domain_error : public logic_error
+  {
+  public:
+    explicit domain_error(const string& __arg);
+  };
+
+
+  class invalid_argument : public logic_error
+  {
+  public:
+    explicit invalid_argument(const string& __arg);
+  };
+
+
+
+  class length_error : public logic_error
+  {
+  public:
+    explicit length_error(const string& __arg);
+  };
+
+
+
+  class out_of_range : public logic_error
+  {
+  public:
+    explicit out_of_range(const string& __arg);
+  };
+
+
+
+
+
+
+  class runtime_error : public exception
+  {
+    string _M_msg;
+
+  public:
+
+    explicit
+    runtime_error(const string& __arg);
+
+    virtual
+    ~runtime_error() throw();
+
+
+
+    virtual const char*
+    what() const throw();
+  };
+
+
+  class range_error : public runtime_error
+  {
+  public:
+    explicit range_error(const string& __arg);
+  };
+
+
+  class overflow_error : public runtime_error
+  {
+  public:
+    explicit overflow_error(const string& __arg);
+  };
+
+
+  class underflow_error : public runtime_error
+  {
+  public:
+    explicit underflow_error(const string& __arg);
+  };
+
+
+
+}
+# 15 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 1 3
+# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
+       
+# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
+# 68 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_raw_storage_iter.h" 1 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_raw_storage_iter.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+  template <class _OutputIterator, class _Tp>
+    class raw_storage_iterator
+    : public iterator<output_iterator_tag, void, void, void, void>
+    {
+    protected:
+      _OutputIterator _M_iter;
+
+    public:
+      explicit
+      raw_storage_iterator(_OutputIterator __x)
+      : _M_iter(__x) {}
+
+      raw_storage_iterator&
+      operator*() { return *this; }
+
+      raw_storage_iterator&
+      operator=(const _Tp& __element)
+      {
+ std::_Construct(&*_M_iter, __element);
+ return *this;
+      }
+
+      raw_storage_iterator<_OutputIterator, _Tp>&
+      operator++()
+      {
+ ++_M_iter;
+ return *this;
+      }
+
+      raw_storage_iterator<_OutputIterator, _Tp>
+      operator++(int)
+      {
+ raw_storage_iterator<_OutputIterator, _Tp> __tmp = *this;
+ ++_M_iter;
+ return __tmp;
+      }
+    };
+
+}
+# 69 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 2 3
+# 103 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 1 3
+# 36 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+  template<typename _Tp1>
+    struct auto_ptr_ref
+    {
+      _Tp1* _M_ptr;
+
+      explicit
+      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
+    } ;
+# 84 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+  template<typename _Tp>
+    class auto_ptr
+    {
+    private:
+      _Tp* _M_ptr;
+
+    public:
+
+      typedef _Tp element_type;
+
+
+
+
+
+
+
+      explicit
+      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
+# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
+# 122 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      template<typename _Tp1>
+        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
+# 133 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      auto_ptr&
+      operator=(auto_ptr& __a) throw()
+      {
+ reset(__a.release());
+ return *this;
+      }
+# 150 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      template<typename _Tp1>
+        auto_ptr&
+        operator=(auto_ptr<_Tp1>& __a) throw()
+        {
+   reset(__a.release());
+   return *this;
+ }
+# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      ~auto_ptr() { delete _M_ptr; }
+# 178 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      element_type&
+      operator*() const throw()
+      {
+ ;
+ return *_M_ptr;
+      }
+
+
+
+
+
+
+
+      element_type*
+      operator->() const throw()
+      {
+ ;
+ return _M_ptr;
+      }
+# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      element_type*
+      get() const throw() { return _M_ptr; }
+# 222 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      element_type*
+      release() throw()
+      {
+ element_type* __tmp = _M_ptr;
+ _M_ptr = 0;
+ return __tmp;
+      }
+# 237 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      void
+      reset(element_type* __p = 0) throw()
+      {
+ if (__p != _M_ptr)
+   {
+     delete _M_ptr;
+     _M_ptr = __p;
+   }
+      }
+# 258 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/backward/auto_ptr.h" 3
+      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
+      : _M_ptr(__ref._M_ptr) { }
+
+      auto_ptr&
+      operator=(auto_ptr_ref<element_type> __ref) throw()
+      {
+ if (__ref._M_ptr != this->get())
+   {
+     delete _M_ptr;
+     _M_ptr = __ref._M_ptr;
+   }
+ return *this;
+      }
+
+      template<typename _Tp1>
+        operator auto_ptr_ref<_Tp1>() throw()
+        { return auto_ptr_ref<_Tp1>(this->release()); }
+
+      template<typename _Tp1>
+        operator auto_ptr<_Tp1>() throw()
+        { return auto_ptr<_Tp1>(this->release()); }
+    } ;
+
+
+
+  template<>
+    class auto_ptr<void>
+    {
+    public:
+      typedef void element_type;
+    } ;
+
+}
+# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/memory" 2 3
+# 17 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/detail/sp_typeinfo.hpp" 1
+# 103 "/usr/include/boost-1_42/boost/detail/sp_typeinfo.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 1 3
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
+       
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
+
+
+
+#pragma GCC visibility push(default)
+
+extern "C++" {
+
+namespace __cxxabiv1
+{
+  class __class_type_info;
+}
+# 79 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
+namespace std
+{
+
+
+
+
+
+
+  class type_info
+  {
+  public:
+
+
+
+
+    virtual ~type_info();
+
+
+
+    const char* name() const
+    { return __name[0] == '*' ? __name + 1 : __name; }
+# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
+    bool before(const type_info& __arg) const
+    { return (__name[0] == '*' && __arg.__name[0] == '*')
+ ? __name < __arg.__name
+ : __builtin_strcmp (__name, __arg.__name) < 0; }
+
+    bool operator==(const type_info& __arg) const
+    {
+      return ((__name == __arg.__name)
+       || (__name[0] != '*' &&
+    __builtin_strcmp (__name, __arg.__name) == 0));
+    }
+# 135 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/typeinfo" 3
+    bool operator!=(const type_info& __arg) const
+    { return !operator==(__arg); }
+
+
+    virtual bool __is_pointer_p() const;
+
+
+    virtual bool __is_function_p() const;
+
+
+
+
+
+
+
+    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
+       unsigned __outer) const;
+
+
+    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
+        void **__obj_ptr) const;
+
+  protected:
+    const char *__name;
+
+    explicit type_info(const char *__n): __name(__n) { }
+
+  private:
+
+    type_info& operator=(const type_info&);
+    type_info(const type_info&);
+  };
+
+
+
+
+
+
+
+  class bad_cast : public exception
+  {
+  public:
+    bad_cast() throw() { }
+
+
+
+    virtual ~bad_cast() throw();
+
+
+    virtual const char* what() const throw();
+  };
+
+
+
+
+
+  class bad_typeid : public exception
+  {
+  public:
+    bad_typeid () throw() { }
+
+
+
+    virtual ~bad_typeid() throw();
+
+
+    virtual const char* what() const throw();
+  };
+}
+
+#pragma GCC visibility pop
+
+}
+# 104 "/usr/include/boost-1_42/boost/detail/sp_typeinfo.hpp" 2
+
+namespace boost
+{
+
+namespace detail
+{
+
+
+
+
+
+
+
+typedef std::type_info sp_typeinfo;
+
+
+
+}
+
+}
+# 20 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/assert.hpp" 1
+# 36 "/usr/include/boost-1_42/boost/assert.hpp"
+# 1 "/usr/include/assert.h" 1 3 4
+# 37 "/usr/include/boost-1_42/boost/assert.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/integer.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/integer.hpp"
+# 1 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/integer_fwd.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 2 3
+# 13 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 14 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/limits.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/limits.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
+# 148 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+
+
+
+  enum float_round_style
+  {
+    round_indeterminate = -1,
+    round_toward_zero = 0,
+    round_to_nearest = 1,
+    round_toward_infinity = 2,
+    round_toward_neg_infinity = 3
+  };
+
+
+
+
+
+
+
+  enum float_denorm_style
+  {
+
+    denorm_indeterminate = -1,
+
+    denorm_absent = 0,
+
+    denorm_present = 1
+  };
+# 190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
+  struct __numeric_limits_base
+  {
+
+
+    static const bool is_specialized = false;
+
+
+
+
+    static const int digits = 0;
+
+    static const int digits10 = 0;
+
+
+
+
+
+
+    static const bool is_signed = false;
+
+
+    static const bool is_integer = false;
+
+
+
+
+    static const bool is_exact = false;
+
+
+    static const int radix = 0;
+
+
+
+    static const int min_exponent = 0;
+
+
+    static const int min_exponent10 = 0;
+
+
+
+    static const int max_exponent = 0;
+
+
+    static const int max_exponent10 = 0;
+
+
+    static const bool has_infinity = false;
+
+
+    static const bool has_quiet_NaN = false;
+
+
+    static const bool has_signaling_NaN = false;
+
+    static const float_denorm_style has_denorm = denorm_absent;
+
+
+    static const bool has_denorm_loss = false;
+
+
+
+    static const bool is_iec559 = false;
+
+
+
+    static const bool is_bounded = false;
+
+
+
+
+    static const bool is_modulo = false;
+
+
+    static const bool traps = false;
+
+    static const bool tinyness_before = false;
+
+
+
+    static const float_round_style round_style = round_toward_zero;
+  };
+# 283 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
+  template<typename _Tp>
+    struct numeric_limits : public __numeric_limits_base
+    {
+
+
+      static _Tp min() throw() { return static_cast<_Tp>(0); }
+
+      static _Tp max() throw() { return static_cast<_Tp>(0); }
+
+
+
+
+
+
+
+      static _Tp epsilon() throw() { return static_cast<_Tp>(0); }
+
+      static _Tp round_error() throw() { return static_cast<_Tp>(0); }
+
+      static _Tp infinity() throw() { return static_cast<_Tp>(0); }
+
+
+
+      static _Tp quiet_NaN() throw() { return static_cast<_Tp>(0); }
+
+
+      static _Tp signaling_NaN() throw() { return static_cast<_Tp>(0); }
+
+
+
+      static _Tp denorm_min() throw() { return static_cast<_Tp>(0); }
+    };
+# 334 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
+  template<>
+    struct numeric_limits<bool>
+    {
+      static const bool is_specialized = true;
+
+      static bool min() throw()
+      { return false; }
+      static bool max() throw()
+      { return true; }
+
+
+
+
+      static const int digits = 1;
+      static const int digits10 = 0;
+
+
+
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static bool epsilon() throw()
+      { return false; }
+      static bool round_error() throw()
+      { return false; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static bool infinity() throw()
+      { return false; }
+      static bool quiet_NaN() throw()
+      { return false; }
+      static bool signaling_NaN() throw()
+      { return false; }
+      static bool denorm_min() throw()
+      { return false; }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+
+
+
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<char>
+    {
+      static const bool is_specialized = true;
+
+      static char min() throw()
+      { return (((char)(-1) < 0) ? (char)1 << (sizeof(char) * 8 - ((char)(-1) < 0)) : (char)0); }
+      static char max() throw()
+      { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }
+
+
+
+
+
+      static const int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
+      static const int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = ((char)(-1) < 0);
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static char epsilon() throw()
+      { return 0; }
+      static char round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static char infinity() throw()
+      { return char(); }
+      static char quiet_NaN() throw()
+      { return char(); }
+      static char signaling_NaN() throw()
+      { return char(); }
+      static char denorm_min() throw()
+      { return static_cast<char>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<signed char>
+    {
+      static const bool is_specialized = true;
+
+      static signed char min() throw()
+      { return -127 - 1; }
+      static signed char max() throw()
+      { return 127; }
+
+
+
+
+
+      static const int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
+      static const int digits10 = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static signed char epsilon() throw()
+      { return 0; }
+      static signed char round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static signed char infinity() throw()
+      { return static_cast<signed char>(0); }
+      static signed char quiet_NaN() throw()
+      { return static_cast<signed char>(0); }
+      static signed char signaling_NaN() throw()
+      { return static_cast<signed char>(0); }
+      static signed char denorm_min() throw()
+      { return static_cast<signed char>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned char>
+    {
+      static const bool is_specialized = true;
+
+      static unsigned char min() throw()
+      { return 0; }
+      static unsigned char max() throw()
+      { return 127 * 2U + 1; }
+
+
+
+
+
+      static const int digits = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
+      static const int digits10 = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned char epsilon() throw()
+      { return 0; }
+      static unsigned char round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static unsigned char infinity() throw()
+      { return static_cast<unsigned char>(0); }
+      static unsigned char quiet_NaN() throw()
+      { return static_cast<unsigned char>(0); }
+      static unsigned char signaling_NaN() throw()
+      { return static_cast<unsigned char>(0); }
+      static unsigned char denorm_min() throw()
+      { return static_cast<unsigned char>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<wchar_t>
+    {
+      static const bool is_specialized = true;
+
+      static wchar_t min() throw()
+      { return (((wchar_t)(-1) < 0) ? (wchar_t)1 << (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) : (wchar_t)0); }
+      static wchar_t max() throw()
+      { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }
+
+
+
+
+
+      static const int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
+      static const int digits10 = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = ((wchar_t)(-1) < 0);
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static wchar_t epsilon() throw()
+      { return 0; }
+      static wchar_t round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static wchar_t infinity() throw()
+      { return wchar_t(); }
+      static wchar_t quiet_NaN() throw()
+      { return wchar_t(); }
+      static wchar_t signaling_NaN() throw()
+      { return wchar_t(); }
+      static wchar_t denorm_min() throw()
+      { return wchar_t(); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+# 744 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/limits" 3
+  template<>
+    struct numeric_limits<short>
+    {
+      static const bool is_specialized = true;
+
+      static short min() throw()
+      { return -32767 - 1; }
+      static short max() throw()
+      { return 32767; }
+
+
+
+
+
+      static const int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
+      static const int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static short epsilon() throw()
+      { return 0; }
+      static short round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static short infinity() throw()
+      { return short(); }
+      static short quiet_NaN() throw()
+      { return short(); }
+      static short signaling_NaN() throw()
+      { return short(); }
+      static short denorm_min() throw()
+      { return short(); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned short>
+    {
+      static const bool is_specialized = true;
+
+      static unsigned short min() throw()
+      { return 0; }
+      static unsigned short max() throw()
+      { return 32767 * 2U + 1; }
+
+
+
+
+
+      static const int digits = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
+      static const int digits10 = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned short epsilon() throw()
+      { return 0; }
+      static unsigned short round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static unsigned short infinity() throw()
+      { return static_cast<unsigned short>(0); }
+      static unsigned short quiet_NaN() throw()
+      { return static_cast<unsigned short>(0); }
+      static unsigned short signaling_NaN() throw()
+      { return static_cast<unsigned short>(0); }
+      static unsigned short denorm_min() throw()
+      { return static_cast<unsigned short>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<int>
+    {
+      static const bool is_specialized = true;
+
+      static int min() throw()
+      { return -2147483647 - 1; }
+      static int max() throw()
+      { return 2147483647; }
+
+
+
+
+
+      static const int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
+      static const int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static int epsilon() throw()
+      { return 0; }
+      static int round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static int infinity() throw()
+      { return static_cast<int>(0); }
+      static int quiet_NaN() throw()
+      { return static_cast<int>(0); }
+      static int signaling_NaN() throw()
+      { return static_cast<int>(0); }
+      static int denorm_min() throw()
+      { return static_cast<int>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned int>
+    {
+      static const bool is_specialized = true;
+
+      static unsigned int min() throw()
+      { return 0; }
+      static unsigned int max() throw()
+      { return 2147483647 * 2U + 1; }
+
+
+
+
+
+      static const int digits = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
+      static const int digits10 = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned int epsilon() throw()
+      { return 0; }
+      static unsigned int round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static unsigned int infinity() throw()
+      { return static_cast<unsigned int>(0); }
+      static unsigned int quiet_NaN() throw()
+      { return static_cast<unsigned int>(0); }
+      static unsigned int signaling_NaN() throw()
+      { return static_cast<unsigned int>(0); }
+      static unsigned int denorm_min() throw()
+      { return static_cast<unsigned int>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<long>
+    {
+      static const bool is_specialized = true;
+
+      static long min() throw()
+      { return -9223372036854775807L - 1; }
+      static long max() throw()
+      { return 9223372036854775807L; }
+
+
+
+
+
+      static const int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
+      static const int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static long epsilon() throw()
+      { return 0; }
+      static long round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static long infinity() throw()
+      { return static_cast<long>(0); }
+      static long quiet_NaN() throw()
+      { return static_cast<long>(0); }
+      static long signaling_NaN() throw()
+      { return static_cast<long>(0); }
+      static long denorm_min() throw()
+      { return static_cast<long>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned long>
+    {
+      static const bool is_specialized = true;
+
+      static unsigned long min() throw()
+      { return 0; }
+      static unsigned long max() throw()
+      { return 9223372036854775807L * 2UL + 1; }
+
+
+
+
+
+      static const int digits = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
+      static const int digits10 = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned long epsilon() throw()
+      { return 0; }
+      static unsigned long round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static unsigned long infinity() throw()
+      { return static_cast<unsigned long>(0); }
+      static unsigned long quiet_NaN() throw()
+      { return static_cast<unsigned long>(0); }
+      static unsigned long signaling_NaN() throw()
+      { return static_cast<unsigned long>(0); }
+      static unsigned long denorm_min() throw()
+      { return static_cast<unsigned long>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<long long>
+    {
+      static const bool is_specialized = true;
+
+      static long long min() throw()
+      { return -9223372036854775807LL - 1; }
+      static long long max() throw()
+      { return 9223372036854775807LL; }
+
+
+
+
+
+      static const int digits = (sizeof(long long) * 8 - ((long long)(-1) < 0));
+      static const int digits10 = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static long long epsilon() throw()
+      { return 0; }
+      static long long round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static long long infinity() throw()
+      { return static_cast<long long>(0); }
+      static long long quiet_NaN() throw()
+      { return static_cast<long long>(0); }
+      static long long signaling_NaN() throw()
+      { return static_cast<long long>(0); }
+      static long long denorm_min() throw()
+      { return static_cast<long long>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<unsigned long long>
+    {
+      static const bool is_specialized = true;
+
+      static unsigned long long min() throw()
+      { return 0; }
+      static unsigned long long max() throw()
+      { return 9223372036854775807LL * 2ULL + 1; }
+
+
+
+
+
+      static const int digits = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
+      static const int digits10 = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643 / 2136);
+
+
+
+      static const bool is_signed = false;
+      static const bool is_integer = true;
+      static const bool is_exact = true;
+      static const int radix = 2;
+      static unsigned long long epsilon() throw()
+      { return 0; }
+      static unsigned long long round_error() throw()
+      { return 0; }
+
+      static const int min_exponent = 0;
+      static const int min_exponent10 = 0;
+      static const int max_exponent = 0;
+      static const int max_exponent10 = 0;
+
+      static const bool has_infinity = false;
+      static const bool has_quiet_NaN = false;
+      static const bool has_signaling_NaN = false;
+      static const float_denorm_style has_denorm = denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static unsigned long long infinity() throw()
+      { return static_cast<unsigned long long>(0); }
+      static unsigned long long quiet_NaN() throw()
+      { return static_cast<unsigned long long>(0); }
+      static unsigned long long signaling_NaN() throw()
+      { return static_cast<unsigned long long>(0); }
+      static unsigned long long denorm_min() throw()
+      { return static_cast<unsigned long long>(0); }
+
+      static const bool is_iec559 = false;
+      static const bool is_bounded = true;
+      static const bool is_modulo = true;
+
+      static const bool traps = true;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_toward_zero;
+    };
+
+
+  template<>
+    struct numeric_limits<float>
+    {
+      static const bool is_specialized = true;
+
+      static float min() throw()
+      { return 1.17549435082228750797e-38F; }
+      static float max() throw()
+      { return 3.40282346638528859812e+38F; }
+
+
+
+
+
+      static const int digits = 24;
+      static const int digits10 = 6;
+
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = false;
+      static const bool is_exact = false;
+      static const int radix = 2;
+      static float epsilon() throw()
+      { return 1.19209289550781250000e-7F; }
+      static float round_error() throw()
+      { return 0.5F; }
+
+      static const int min_exponent = (-125);
+      static const int min_exponent10 = (-37);
+      static const int max_exponent = 128;
+      static const int max_exponent10 = 38;
+
+      static const bool has_infinity = 1;
+      static const bool has_quiet_NaN = 1;
+      static const bool has_signaling_NaN = has_quiet_NaN;
+      static const float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static float infinity() throw()
+      { return __builtin_huge_valf (); }
+      static float quiet_NaN() throw()
+      { return __builtin_nanf (""); }
+      static float signaling_NaN() throw()
+      { return __builtin_nansf (""); }
+      static float denorm_min() throw()
+      { return 1.40129846432481707092e-45F; }
+
+      static const bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_to_nearest;
+    };
+
+
+
+
+
+
+  template<>
+    struct numeric_limits<double>
+    {
+      static const bool is_specialized = true;
+
+      static double min() throw()
+      { return ((double)2.22507385850720138309e-308L); }
+      static double max() throw()
+      { return ((double)1.79769313486231570815e+308L); }
+
+
+
+
+
+      static const int digits = 53;
+      static const int digits10 = 15;
+
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = false;
+      static const bool is_exact = false;
+      static const int radix = 2;
+      static double epsilon() throw()
+      { return ((double)2.22044604925031308085e-16L); }
+      static double round_error() throw()
+      { return 0.5; }
+
+      static const int min_exponent = (-1021);
+      static const int min_exponent10 = (-307);
+      static const int max_exponent = 1024;
+      static const int max_exponent10 = 308;
+
+      static const bool has_infinity = 1;
+      static const bool has_quiet_NaN = 1;
+      static const bool has_signaling_NaN = has_quiet_NaN;
+      static const float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static const bool has_denorm_loss = false;
+
+      static double infinity() throw()
+      { return __builtin_huge_val(); }
+      static double quiet_NaN() throw()
+      { return __builtin_nan (""); }
+      static double signaling_NaN() throw()
+      { return __builtin_nans (""); }
+      static double denorm_min() throw()
+      { return ((double)4.94065645841246544177e-324L); }
+
+      static const bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_to_nearest;
+    };
+
+
+
+
+
+
+  template<>
+    struct numeric_limits<long double>
+    {
+      static const bool is_specialized = true;
+
+      static long double min() throw()
+      { return 3.36210314311209350626e-4932L; }
+      static long double max() throw()
+      { return 1.18973149535723176502e+4932L; }
+
+
+
+
+
+      static const int digits = 64;
+      static const int digits10 = 18;
+
+
+
+
+      static const bool is_signed = true;
+      static const bool is_integer = false;
+      static const bool is_exact = false;
+      static const int radix = 2;
+      static long double epsilon() throw()
+      { return 1.08420217248550443401e-19L; }
+      static long double round_error() throw()
+      { return 0.5L; }
+
+      static const int min_exponent = (-16381);
+      static const int min_exponent10 = (-4931);
+      static const int max_exponent = 16384;
+      static const int max_exponent10 = 4932;
+
+      static const bool has_infinity = 1;
+      static const bool has_quiet_NaN = 1;
+      static const bool has_signaling_NaN = has_quiet_NaN;
+      static const float_denorm_style has_denorm
+ = bool(1) ? denorm_present : denorm_absent;
+      static const bool has_denorm_loss
+ = false;
+
+      static long double infinity() throw()
+      { return __builtin_huge_vall (); }
+      static long double quiet_NaN() throw()
+      { return __builtin_nanl (""); }
+      static long double signaling_NaN() throw()
+      { return __builtin_nansl (""); }
+      static long double denorm_min() throw()
+      { return 3.64519953188247460253e-4951L; }
+
+      static const bool is_iec559
+ = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
+      static const bool is_bounded = true;
+      static const bool is_modulo = false;
+
+      static const bool traps = false;
+      static const bool tinyness_before = false;
+      static const float_round_style round_style = round_to_nearest;
+    };
+
+
+
+
+
+}
+# 20 "/usr/include/boost-1_42/boost/limits.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/cstdint.hpp" 1
+# 100 "/usr/include/boost-1_42/boost/cstdint.hpp"
+namespace boost
+{
+
+  using ::int8_t;
+  using ::int_least8_t;
+  using ::int_fast8_t;
+  using ::uint8_t;
+  using ::uint_least8_t;
+  using ::uint_fast8_t;
+
+  using ::int16_t;
+  using ::int_least16_t;
+  using ::int_fast16_t;
+  using ::uint16_t;
+  using ::uint_least16_t;
+  using ::uint_fast16_t;
+
+  using ::int32_t;
+  using ::int_least32_t;
+  using ::int_fast32_t;
+  using ::uint32_t;
+  using ::uint_least32_t;
+  using ::uint_fast32_t;
+
+
+
+  using ::int64_t;
+  using ::int_least64_t;
+  using ::int_fast64_t;
+  using ::uint64_t;
+  using ::uint_least64_t;
+  using ::uint_fast64_t;
+
+
+
+  using ::intmax_t;
+  using ::uintmax_t;
+
+}
+# 370 "/usr/include/boost-1_42/boost/cstdint.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 371 "/usr/include/boost-1_42/boost/cstdint.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/integer_fwd.hpp" 2
+
+
+namespace boost
+{
+
+
+
+
+
+
+
+     typedef boost::uintmax_t static_min_max_unsigned_type;
+     typedef boost::intmax_t static_min_max_signed_type;
+     typedef boost::uintmax_t static_log2_argument_type;
+     typedef int static_log2_result_type;
+# 42 "/usr/include/boost-1_42/boost/integer_fwd.hpp"
+template < class T >
+    class integer_traits;
+
+template < >
+    class integer_traits< bool >;
+
+template < >
+    class integer_traits< char >;
+
+template < >
+    class integer_traits< signed char >;
+
+template < >
+    class integer_traits< unsigned char >;
+
+
+template < >
+    class integer_traits< wchar_t >;
+
+
+template < >
+    class integer_traits< short >;
+
+template < >
+    class integer_traits< unsigned short >;
+
+template < >
+    class integer_traits< int >;
+
+template < >
+    class integer_traits< unsigned int >;
+
+template < >
+    class integer_traits< long >;
+
+template < >
+    class integer_traits< unsigned long >;
+
+
+template < >
+    class integer_traits< ::boost::long_long_type>;
+
+template < >
+    class integer_traits< ::boost::ulong_long_type >;
+
+
+
+
+
+template < typename LeastInt >
+    struct int_fast_t;
+
+template< int Bits >
+    struct int_t;
+
+template< int Bits >
+    struct uint_t;
+
+
+    template< boost::long_long_type MaxValue >
+
+
+
+    struct int_max_value_t;
+
+
+  template< boost::long_long_type MinValue >
+
+
+
+    struct int_min_value_t;
+
+
+  template< boost::ulong_long_type MaxValue >
+
+
+
+    struct uint_value_t;
+
+
+
+
+template < std::size_t Bit >
+    struct high_bit_mask_t;
+
+template < std::size_t Bits >
+    struct low_bits_mask_t;
+
+template < >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;
+
+
+template < >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned short>::digits >;
+
+
+
+template < >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned int>::digits >;
+
+
+
+template < >
+    struct low_bits_mask_t< ::std::numeric_limits<unsigned long>::digits >;
+
+
+
+
+
+template <static_log2_argument_type Value >
+    struct static_log2;
+
+template <> struct static_log2<0u>;
+
+
+
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+    struct static_signed_min;
+
+template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
+    struct static_signed_max;
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+    struct static_unsigned_min;
+
+template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
+    struct static_unsigned_max;
+
+}
+# 19 "/usr/include/boost-1_42/boost/integer.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/integer_traits.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/integer_traits.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 24 "/usr/include/boost-1_42/boost/integer_traits.hpp" 2
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 28 "/usr/include/boost-1_42/boost/integer_traits.hpp" 2
+# 39 "/usr/include/boost-1_42/boost/integer_traits.hpp"
+       
+# 40 "/usr/include/boost-1_42/boost/integer_traits.hpp" 3
+
+
+namespace boost {
+template<class T>
+class integer_traits : public std::numeric_limits<T>
+{
+public:
+  static const bool is_integral = false;
+};
+
+namespace detail {
+template<class T, T min_val, T max_val>
+class integer_traits_base
+{
+public:
+  static const bool is_integral = true;
+  static const T const_min = min_val;
+  static const T const_max = max_val;
+};
+
+
+
+template<class T, T min_val, T max_val>
+const bool integer_traits_base<T, min_val, max_val>::is_integral;
+
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_min;
+
+template<class T, T min_val, T max_val>
+const T integer_traits_base<T, min_val, max_val>::const_max;
+
+
+}
+
+template<>
+class integer_traits<bool>
+  : public std::numeric_limits<bool>,
+    public detail::integer_traits_base<bool, false, true>
+{ };
+
+template<>
+class integer_traits<char>
+  : public std::numeric_limits<char>,
+    public detail::integer_traits_base<char, (-127 - 1), 127>
+{ };
+
+template<>
+class integer_traits<signed char>
+  : public std::numeric_limits<signed char>,
+    public detail::integer_traits_base<signed char, (-127 - 1), 127>
+{ };
+
+template<>
+class integer_traits<unsigned char>
+  : public std::numeric_limits<unsigned char>,
+    public detail::integer_traits_base<unsigned char, 0, (127 * 2 + 1)>
+{ };
+
+
+template<>
+class integer_traits<wchar_t>
+  : public std::numeric_limits<wchar_t>,
+
+
+
+    public detail::integer_traits_base<wchar_t, (-2147483647 - 1), (2147483647)>
+# 130 "/usr/include/boost-1_42/boost/integer_traits.hpp" 3
+{ };
+
+
+template<>
+class integer_traits<short>
+  : public std::numeric_limits<short>,
+    public detail::integer_traits_base<short, (-32767 - 1), 32767>
+{ };
+
+template<>
+class integer_traits<unsigned short>
+  : public std::numeric_limits<unsigned short>,
+    public detail::integer_traits_base<unsigned short, 0, (32767 * 2 + 1)>
+{ };
+
+template<>
+class integer_traits<int>
+  : public std::numeric_limits<int>,
+    public detail::integer_traits_base<int, (-2147483647 - 1), 2147483647>
+{ };
+
+template<>
+class integer_traits<unsigned int>
+  : public std::numeric_limits<unsigned int>,
+    public detail::integer_traits_base<unsigned int, 0, (2147483647 * 2U + 1U)>
+{ };
+
+template<>
+class integer_traits<long>
+  : public std::numeric_limits<long>,
+    public detail::integer_traits_base<long, (-9223372036854775807L - 1L), 9223372036854775807L>
+{ };
+
+template<>
+class integer_traits<unsigned long>
+  : public std::numeric_limits<unsigned long>,
+    public detail::integer_traits_base<unsigned long, 0, (9223372036854775807L * 2UL + 1UL)>
+{ };
+
+
+
+
+template<>
+class integer_traits< ::boost::long_long_type>
+  : public std::numeric_limits< ::boost::long_long_type>,
+    public detail::integer_traits_base< ::boost::long_long_type, (-9223372036854775807LL -1), 9223372036854775807LL>
+{ };
+
+template<>
+class integer_traits< ::boost::ulong_long_type>
+  : public std::numeric_limits< ::boost::ulong_long_type>,
+    public detail::integer_traits_base< ::boost::ulong_long_type, 0, (9223372036854775807LL * 2ULL + 1)>
+{ };
+# 256 "/usr/include/boost-1_42/boost/integer_traits.hpp" 3
+}
+# 21 "/usr/include/boost-1_42/boost/integer.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/cstdint.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/integer.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/integer.hpp"
+       
+# 34 "/usr/include/boost-1_42/boost/integer.hpp" 3
+
+
+namespace boost
+{
+
+
+
+
+
+  template< typename LeastInt >
+  struct int_fast_t
+  {
+     typedef LeastInt fast;
+     typedef fast type;
+  };
+
+  namespace detail{
+
+
+  template< int Category > struct int_least_helper {};
+
+
+
+
+
+  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };
+
+  template<> struct int_least_helper<2> { typedef long least; };
+  template<> struct int_least_helper<3> { typedef int least; };
+  template<> struct int_least_helper<4> { typedef short least; };
+  template<> struct int_least_helper<5> { typedef signed char least; };
+
+  template<> struct int_least_helper<6> { typedef boost::ulong_long_type least; };
+
+  template<> struct int_least_helper<7> { typedef unsigned long least; };
+  template<> struct int_least_helper<8> { typedef unsigned int least; };
+  template<> struct int_least_helper<9> { typedef unsigned short least; };
+  template<> struct int_least_helper<10> { typedef unsigned char least; };
+
+  template <int Bits>
+  struct exact_signed_base_helper{};
+  template <int Bits>
+  struct exact_unsigned_base_helper{};
+
+  template <> struct exact_signed_base_helper<sizeof(signed char)* 8> { typedef signed char exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* 8> { typedef unsigned char exact; };
+
+  template <> struct exact_signed_base_helper<sizeof(short)* 8> { typedef short exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* 8> { typedef unsigned short exact; };
+
+
+  template <> struct exact_signed_base_helper<sizeof(int)* 8> { typedef int exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* 8> { typedef unsigned int exact; };
+
+
+  template <> struct exact_signed_base_helper<sizeof(long)* 8> { typedef long exact; };
+  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* 8> { typedef unsigned long exact; };
+# 102 "/usr/include/boost-1_42/boost/integer.hpp" 3
+  }
+
+
+
+
+  template< int Bits >
+  struct int_t : public detail::exact_signed_base_helper<Bits>
+  {
+      typedef typename detail::int_least_helper
+        <
+
+          (Bits-1 <= (int)(sizeof(boost::long_long_type) * 8)) +
+
+
+
+          (Bits-1 <= ::std::numeric_limits<long>::digits) +
+          (Bits-1 <= ::std::numeric_limits<int>::digits) +
+          (Bits-1 <= ::std::numeric_limits<short>::digits) +
+          (Bits-1 <= ::std::numeric_limits<signed char>::digits)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+  template< int Bits >
+  struct uint_t : public detail::exact_unsigned_base_helper<Bits>
+  {
+# 139 "/usr/include/boost-1_42/boost/integer.hpp" 3
+      typedef typename detail::int_least_helper
+        <
+          5 +
+
+          (Bits-1 <= (int)(sizeof(boost::long_long_type) * 8)) +
+
+
+
+          (Bits <= ::std::numeric_limits<unsigned long>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned int>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned short>::digits) +
+          (Bits <= ::std::numeric_limits<unsigned char>::digits)
+        >::least least;
+
+      typedef typename int_fast_t<least>::type fast;
+
+  };
+
+
+
+
+
+  template< boost::long_long_type MaxValue >
+
+
+
+  struct int_max_value_t
+  {
+      typedef typename detail::int_least_helper
+        <
+
+          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +
+
+
+
+          (MaxValue <= ::boost::integer_traits<long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<signed char>::const_max)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+  template< boost::long_long_type MinValue >
+
+
+
+  struct int_min_value_t
+  {
+      typedef typename detail::int_least_helper
+        <
+
+          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +
+
+
+
+          (MinValue >= ::boost::integer_traits<long>::const_min) +
+          (MinValue >= ::boost::integer_traits<int>::const_min) +
+          (MinValue >= ::boost::integer_traits<short>::const_min) +
+          (MinValue >= ::boost::integer_traits<signed char>::const_min)
+        >::least least;
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+
+  template< boost::ulong_long_type MaxValue >
+
+
+
+  struct uint_value_t
+  {
+# 233 "/usr/include/boost-1_42/boost/integer.hpp" 3
+      typedef typename detail::int_least_helper
+        <
+          5 +
+
+          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +
+
+
+
+          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
+          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
+        >::least least;
+
+      typedef typename int_fast_t<least>::type fast;
+  };
+
+
+}
+# 22 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/intrinsics.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp" 2
+
+namespace boost {
+
+
+
+
+
+template< typename T > struct is_void : ::boost::integral_constant<bool,false> { };
+template<> struct is_void< void > : ::boost::integral_constant<bool,true> { };
+
+
+template<> struct is_void< void const > : ::boost::integral_constant<bool,true> { };
+template<> struct is_void< void volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_void< void const volatile > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/type_traits/is_void.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp" 2
+
+namespace boost {
+
+
+
+
+
+
+
+template< typename T > struct is_integral : ::boost::integral_constant<bool,false> { };
+
+template<> struct is_integral< unsigned char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned char const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< unsigned short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned short const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< unsigned int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned int const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< unsigned long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< unsigned long const volatile > : ::boost::integral_constant<bool,true> { };
+
+template<> struct is_integral< signed char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed char const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< signed short > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed short const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< signed int > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed int const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< signed long > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< signed long const volatile > : ::boost::integral_constant<bool,true> { };
+
+template<> struct is_integral< bool > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< bool const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< char > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< char const volatile > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+template<> struct is_integral< wchar_t > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< wchar_t const volatile > : ::boost::integral_constant<bool,true> { };
+# 65 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp"
+template<> struct is_integral< ::boost::ulong_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::ulong_long_type const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_integral< ::boost::long_long_type > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_integral< ::boost::long_long_type const volatile > : ::boost::integral_constant<bool,true> { };
+
+
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 77 "/usr/include/boost-1_42/boost/type_traits/is_integral.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp" 2
+
+namespace boost {
+
+
+template< typename T > struct is_float : ::boost::integral_constant<bool,false> { };
+template<> struct is_float< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< float const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_float< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< double const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_float< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_float< long double const volatile > : ::boost::integral_constant<bool,true> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/type_traits/is_float.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_or.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/detail/ice_or.hpp"
+namespace boost {
+namespace type_traits {
+
+template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false>
+struct ice_or;
+
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_or
+{
+    static const bool value = true;
+};
+
+template <>
+struct ice_or<false, false, false, false, false, false, false>
+{
+    static const bool value = false;
+};
+
+}
+}
+# 16 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
+
+namespace boost {
+
+
+namespace detail {
+
+template< typename T >
+struct is_arithmetic_impl
+{
+    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value)
+
+
+
+                  ;
+};
+
+}
+
+
+
+
+
+
+template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 50 "/usr/include/boost-1_42/boost/type_traits/is_arithmetic.hpp" 2
+# 13 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp" 2
+
+namespace boost {
+# 181 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp"
+template< typename T > struct is_enum : ::boost::integral_constant<bool,__is_enum(T)> { };
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/type_traits/is_enum.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
+namespace boost {
+namespace type_traits {
+
+template <typename T>
+struct is_mem_fun_pointer_impl
+{
+    static const bool value = false;
+};
+
+
+
+
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() > { static const bool value = true; };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) > { static const bool value = true; };
+
+
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() const > { static const bool value = true; };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() volatile > { static const bool value = true; };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)() const volatile > { static const bool value = true; };
+
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) const > { static const bool value = true; };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) volatile > { static const bool value = true; };
+
+template <class R, class T >
+struct is_mem_fun_pointer_impl<R (T::*)( ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) > { static const bool value = true; };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const > { static const bool value = true; };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) > { static const bool value = true; };
+
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24) const volatile > { static const bool value = true; };
+
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) volatile > { static const bool value = true; };
+
+template <class R, class T , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_mem_fun_pointer_impl<R (T::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...) const volatile > { static const bool value = true; };
+# 776 "/usr/include/boost-1_42/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp"
+}
+}
+# 25 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 2
+
+namespace boost {
+
+
+
+
+
+template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> { };
+# 132 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 135 "/usr/include/boost-1_42/boost/type_traits/is_member_function_pointer.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 2
+# 39 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 40 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 2
+
+namespace boost {
+# 50 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
+template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> { };
+template< typename T, typename U > struct is_member_pointer< U T::* > : ::boost::integral_constant<bool,true> { };
+
+
+template< typename T, typename U > struct is_member_pointer< U T::*const > : ::boost::integral_constant<bool,true> { };
+template< typename T, typename U > struct is_member_pointer< U T::*volatile > : ::boost::integral_constant<bool,true> { };
+template< typename T, typename U > struct is_member_pointer< U T::*const volatile > : ::boost::integral_constant<bool,true> { };
+# 112 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 115 "/usr/include/boost-1_42/boost/type_traits/is_member_pointer.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_and.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/ice_and.hpp"
+namespace boost {
+namespace type_traits {
+
+template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true>
+struct ice_and;
+
+template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7>
+struct ice_and
+{
+    static const bool value = false;
+};
+
+template <>
+struct ice_and<true, true, true, true, true, true, true>
+{
+    static const bool value = true;
+};
+
+}
+}
+# 26 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_not.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/detail/ice_not.hpp"
+namespace boost {
+namespace type_traits {
+
+template <bool b>
+struct ice_not
+{
+    static const bool value = true;
+};
+
+template <>
+struct ice_not<true>
+{
+    static const bool value = false;
+};
+
+}
+}
+# 27 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
+# 41 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 42 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
+
+namespace boost {
+
+
+
+
+
+namespace detail {
+
+template< typename T > struct is_pointer_helper
+{
+    static const bool value = false;
+};
+# 63 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
+template< typename T > struct is_pointer_helper<T*> { static const bool value = true; };
+
+
+
+template< typename T >
+struct is_pointer_impl
+{
+# 80 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
+    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value)
+
+
+
+
+
+
+         ;
+
+};
+
+}
+
+template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> { };
+# 158 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 161 "/usr/include/boost-1_42/boost/type_traits/is_pointer.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_scalar_impl
+{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value, ::boost::is_pointer<T>::value, ::boost::is_member_pointer<T>::value >::value)
+
+
+
+
+
+                ;
+};
+
+
+
+template <> struct is_scalar_impl<void>{ static const bool value = false; };
+
+template <> struct is_scalar_impl<void const>{ static const bool value = false; };
+template <> struct is_scalar_impl<void volatile>{ static const bool value = false; };
+template <> struct is_scalar_impl<void const volatile>{ static const bool value = false; };
+
+
+}
+
+template< typename T > struct is_scalar : ::boost::integral_constant<bool,::boost::detail::is_scalar_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 54 "/usr/include/boost-1_42/boost/type_traits/is_scalar.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 19 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2
+
+namespace boost {
+
+
+template< typename T > struct is_POD;
+
+namespace detail {
+
+
+
+template <typename T> struct is_pod_impl
+{
+    static const bool value = (::boost::type_traits::ice_or< ::boost::is_scalar<T>::value, ::boost::is_void<T>::value, __is_pod(T) >::value)
+
+
+
+
+
+                   ;
+};
+
+
+template <typename T, std::size_t sz>
+struct is_pod_impl<T[sz]>
+    : is_pod_impl<T>
+{
+};
+# 118 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp"
+template<> struct is_pod_impl< void > { static const bool value = (true); };
+
+
+template<> struct is_pod_impl< void const > { static const bool value = (true); };
+template<> struct is_pod_impl< void volatile > { static const bool value = (true); };
+template<> struct is_pod_impl< void const volatile > { static const bool value = (true); };
+
+
+}
+
+template< typename T > struct is_POD : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };
+template< typename T > struct is_pod : ::boost::integral_constant<bool,::boost::detail::is_pod_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 134 "/usr/include/boost-1_42/boost/type_traits/is_pod.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_copy_impl
+{
+   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, (__has_trivial_copy(T) && !is_reference<T>::value) >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value)
+
+
+
+
+
+
+                ;
+};
+
+}
+
+template< typename T > struct has_trivial_copy : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };
+template< typename T > struct has_trivial_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_copy_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 48 "/usr/include/boost-1_42/boost/type_traits/has_trivial_copy.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_dtor_impl
+{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_destructor(T) >::value)
+
+
+
+                ;
+};
+
+}
+
+template< typename T > struct has_trivial_destructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_dtor_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/type_traits/has_trivial_destructor.hpp" 2
+# 24 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 25 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 2
+
+namespace boost {
+
+
+
+
+template< typename T > struct is_array : ::boost::integral_constant<bool,false> { };
+
+template< typename T, std::size_t N > struct is_array< T[N] > : ::boost::integral_constant<bool,true> { };
+template< typename T, std::size_t N > struct is_array< T const[N] > : ::boost::integral_constant<bool,true> { };
+template< typename T, std::size_t N > struct is_array< T volatile[N] > : ::boost::integral_constant<bool,true> { };
+template< typename T, std::size_t N > struct is_array< T const volatile[N] > : ::boost::integral_constant<bool,true> { };
+
+template< typename T > struct is_array< T[] > : ::boost::integral_constant<bool,true> { };
+template< typename T > struct is_array< T const[] > : ::boost::integral_constant<bool,true> { };
+template< typename T > struct is_array< T volatile[] > : ::boost::integral_constant<bool,true> { };
+template< typename T > struct is_array< T const volatile[] > : ::boost::integral_constant<bool,true> { };
+# 87 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 90 "/usr/include/boost-1_42/boost/type_traits/is_array.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp" 2
+
+namespace boost {
+
+namespace detail {
+# 36 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp"
+template <typename T> struct is_union_impl
+{
+   static const bool value = __is_union(T);
+};
+
+}
+
+template< typename T > struct is_union : ::boost::integral_constant<bool,::boost::detail::is_union_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 48 "/usr/include/boost-1_42/boost/type_traits/is_union.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/type_traits/composite_traits.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/ice.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/ice.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/yes_no_type.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/yes_no_type.hpp"
+namespace boost {
+namespace type_traits {
+
+typedef char yes_type;
+struct no_type
+{
+   char padding[8];
+};
+
+}
+}
+# 15 "/usr/include/boost-1_42/boost/type_traits/ice.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/ice_eq.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/detail/ice_eq.hpp"
+namespace boost {
+namespace type_traits {
+
+template <int b1, int b2>
+struct ice_eq
+{
+    static const bool value = (b1 == b2);
+};
+
+template <int b1, int b2>
+struct ice_ne
+{
+    static const bool value = (b1 != b2);
+};
+
+
+template <int b1, int b2> bool const ice_eq<b1,b2>::value;
+template <int b1, int b2> bool const ice_ne<b1,b2>::value;
+
+
+}
+}
+# 19 "/usr/include/boost-1_42/boost/type_traits/ice.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/ref.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/ref.hpp"
+# 1 "/usr/include/boost-1_42/boost/utility/addressof.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/utility/addressof.hpp"
+namespace boost
+{
+
+namespace detail
+{
+
+template<class T> struct addr_impl_ref
+{
+    T & v_;
+
+    inline addr_impl_ref( T & v ): v_( v ) {}
+    inline operator T& () const { return v_; }
+
+private:
+    addr_impl_ref & operator=(const addr_impl_ref &);
+};
+
+template<class T> struct addressof_impl
+{
+    static inline T * f( T & v, long )
+    {
+        return reinterpret_cast<T*>(
+            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
+    }
+
+    static inline T * f( T * v, int )
+    {
+        return v;
+    }
+};
+
+}
+
+template<class T> T * addressof( T & v )
+{
+
+
+
+
+
+
+    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
+
+
+}
+# 100 "/usr/include/boost-1_42/boost/utility/addressof.hpp"
+}
+# 12 "/usr/include/boost-1_42/boost/ref.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/ref.hpp"
+namespace boost
+{
+
+template<class T> class reference_wrapper
+{
+public:
+    typedef T type;
+
+
+
+
+
+
+
+    explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+
+
+
+    operator T& () const { return *t_; }
+
+    T& get() const { return *t_; }
+
+    T* get_pointer() const { return t_; }
+
+private:
+
+    T* t_;
+};
+
+
+
+
+
+
+
+template<class T> inline reference_wrapper<T> const ref(T & t)
+{
+    return reference_wrapper<T>(t);
+}
+
+template<class T> inline reference_wrapper<T const> const cref(T const & t)
+{
+    return reference_wrapper<T const>(t);
+}
+
+
+
+
+
+template<typename T>
+class is_reference_wrapper
+    : public mpl::false_
+{
+};
+
+template<typename T>
+class unwrap_reference
+{
+ public:
+    typedef T type;
+};
+# 106 "/usr/include/boost-1_42/boost/ref.hpp"
+template<typename T> class is_reference_wrapper< reference_wrapper<T> > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> > { public: typedef T type; };
+
+template<typename T> class is_reference_wrapper< reference_wrapper<T> const > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const > { public: typedef T type; };
+template<typename T> class is_reference_wrapper< reference_wrapper<T> volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> volatile > { public: typedef T type; };
+template<typename T> class is_reference_wrapper< reference_wrapper<T> const volatile > : public mpl::true_ { }; template<typename T> class unwrap_reference< reference_wrapper<T> const volatile > { public: typedef T type; };
+# 176 "/usr/include/boost-1_42/boost/ref.hpp"
+template <class T> inline typename unwrap_reference<T>::type&
+unwrap_ref(T& t)
+{
+    return t;
+}
+
+template<class T> inline T* get_pointer( reference_wrapper<T> const & r )
+{
+    return r.get_pointer();
+}
+
+}
+# 30 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/if.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/if.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/integral.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/eti.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp" 2
+# 73 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct value_type_wknd
+{
+    typedef typename T::value_type type;
+};
+# 87 "/usr/include/boost-1_42/boost/mpl/aux_/value_wknd.hpp"
+}}}
+# 18 "/usr/include/boost-1_42/boost/mpl/if.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/void_fwd.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/void_fwd.hpp"
+namespace mpl_ {
+
+struct void_;
+
+}
+namespace boost { namespace mpl { using ::mpl_::void_; } }
+# 18 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na_fwd.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/na_fwd.hpp"
+namespace mpl_ {
+
+
+struct na
+{
+    typedef na type;
+    enum { value = 0 };
+};
+
+}
+namespace boost { namespace mpl { using ::mpl_::na; } }
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+template< typename T >
+struct is_na
+    : false_
+{
+
+
+
+};
+
+template<>
+struct is_na<na>
+    : true_
+{
+
+
+
+};
+
+template< typename T >
+struct is_not_na
+    : true_
+{
+
+
+
+};
+
+template<>
+struct is_not_na<na>
+    : false_
+{
+
+
+
+};
+
+
+template< typename T, typename U > struct if_na
+{
+    typedef T type;
+};
+
+template< typename U > struct if_na<na,U>
+{
+    typedef U type;
+};
+# 93 "/usr/include/boost-1_42/boost/mpl/aux_/na.hpp"
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/lambda_arity_param.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/mpl/lambda_fwd.hpp" 2
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename T = na
+    , typename Tag = void_
+    , typename Arity = int_< aux::template_arity<T>::value >
+
+
+    >
+struct lambda;
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arity.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/arity.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/dtp.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/arity.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/enum.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/limits/arity.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/and.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/logical/and.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/bitand.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/logical/and.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/identity.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/identity.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/facilities/identity.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/identity.hpp" 2
+# 24 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/empty.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
+# 66 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/dec.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 2
+# 41 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/control/expr_iif.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/is_binary.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/detail/is_binary.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/check.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/detail/is_binary.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/compl.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/list/adt.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_left.hpp" 2
+# 42 "/usr/include/boost-1_42/boost/preprocessor/list/fold_left.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_right.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_right.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/reverse.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/list/detail/fold_right.hpp" 2
+# 38 "/usr/include/boost-1_42/boost/preprocessor/list/fold_right.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
+# 48 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/control/detail/while.hpp" 1
+# 49 "/usr/include/boost-1_42/boost/preprocessor/control/while.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/elem.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/add.hpp" 2
+# 67 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/sub.hpp" 1
+# 68 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/mpl/aux_/na_spec.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/if.hpp" 2
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<
+      bool C
+    , typename T1
+    , typename T2
+    >
+struct if_c
+{
+    typedef T1 type;
+};
+
+template<
+      typename T1
+    , typename T2
+    >
+struct if_c<false,T1,T2>
+{
+    typedef T2 type;
+};
+
+
+
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = na
+    >
+struct if_
+{
+ private:
+
+    typedef if_c<
+
+
+
+          static_cast<bool>(T1::value)
+
+        , T2
+        , T3
+        > almost_type_;
+
+ public:
+    typedef typename almost_type_::type type;
+
+   
+};
+# 131 "/usr/include/boost-1_42/boost/mpl/if.hpp"
+template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }
+
+}}
+# 31 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 14 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/size_t.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/size_t.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/size_t_fwd.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/size_t_fwd.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 20 "/usr/include/boost-1_42/boost/mpl/size_t_fwd.hpp" 2
+
+namespace mpl_ {
+
+template< std::size_t N > struct size_t;
+
+}
+namespace boost { namespace mpl { using ::mpl_::size_t; } }
+# 18 "/usr/include/boost-1_42/boost/mpl/size_t.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
+# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+namespace mpl_ {
+
+template< std::size_t N >
+struct size_t
+{
+    static const std::size_t value = N;
+
+
+
+
+
+    typedef size_t type;
+
+    typedef std::size_t value_type;
+    typedef integral_c_tag tag;
+# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+    typedef mpl_::size_t< static_cast<std::size_t>((value + 1)) > next;
+    typedef mpl_::size_t< static_cast<std::size_t>((value - 1)) > prior;
+
+
+
+
+
+
+    operator std::size_t() const { return static_cast<std::size_t>(this->value); }
+};
+
+
+template< std::size_t N >
+std::size_t const mpl_::size_t< N >::value;
+
+
+}
+# 24 "/usr/include/boost-1_42/boost/mpl/size_t.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 20 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
+namespace boost {
+
+template <typename T> struct alignment_of;
+
+
+namespace detail {
+
+
+
+
+
+template <typename T>
+struct alignment_of_hack
+{
+    char c;
+    T t;
+    alignment_of_hack();
+};
+
+
+
+
+template <unsigned A, unsigned S>
+struct alignment_logic
+{
+    static const std::size_t value = A < S ? A : S;
+};
+
+
+template< typename T >
+struct alignment_of_impl
+{
+# 83 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
+   static const std::size_t value = __alignof__(T);
+
+};
+
+}
+
+template< typename T > struct alignment_of : ::boost::integral_constant<std::size_t,::boost::detail::alignment_of_impl<T>::value> { };
+
+
+
+
+template <typename T>
+struct alignment_of<T&>
+    : alignment_of<T*>
+{
+};
+# 109 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
+template<> struct alignment_of<void> : ::boost::integral_constant<std::size_t,0> { };
+
+template<> struct alignment_of<void const> : ::boost::integral_constant<std::size_t,0> { };
+template<> struct alignment_of<void volatile> : ::boost::integral_constant<std::size_t,0> { };
+template<> struct alignment_of<void const volatile> : ::boost::integral_constant<std::size_t,0> { };
+
+
+}
+# 125 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_undef.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/type_traits/alignment_of.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/utility/enable_if.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/utility/enable_if.hpp"
+namespace boost
+{
+
+  template <bool B, class T = void>
+  struct enable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct enable_if_c<false, T> {};
+
+  template <class Cond, class T = void>
+  struct enable_if : public enable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_enable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_enable_if_c<false, T> {};
+
+  template <class Cond, class T>
+  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+  template <bool B, class T = void>
+  struct disable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct disable_if_c<true, T> {};
+
+  template <class Cond, class T = void>
+  struct disable_if : public disable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_disable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_disable_if_c<true, T> {};
+
+  template <class Cond, class T>
+  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+}
+# 35 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/function_equal.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/function_equal.hpp"
+namespace boost {
+
+template<typename F, typename G>
+  bool function_equal_impl(const F& f, const G& g, long)
+  { return f == g; }
+
+
+
+
+template<typename F, typename G>
+  bool function_equal(const F& f, const G& g)
+  { return function_equal_impl(f, g, 0); }
+
+}
+# 39 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/function/function_fwd.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/function/function_fwd.hpp"
+namespace boost {
+  class bad_function_call;
+
+
+
+  template<typename Signature> class function;
+
+  template<typename Signature>
+  inline void swap(function<Signature>& f1, function<Signature>& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+
+  template<typename R> class function0;
+  template<typename R, typename T1> class function1;
+  template<typename R, typename T1, typename T2> class function2;
+  template<typename R, typename T1, typename T2, typename T3> class function3;
+  template<typename R, typename T1, typename T2, typename T3, typename T4>
+    class function4;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5>
+    class function5;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6>
+    class function6;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7>
+    class function7;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8>
+    class function8;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9>
+    class function9;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9,
+           typename T10>
+    class function10;
+}
+# 40 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 62 "/usr/include/boost-1_42/boost/function/function_base.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 2 3
+# 74 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::memchr;
+  using ::memcmp;
+  using ::memcpy;
+  using ::memmove;
+  using ::memset;
+  using ::strcat;
+  using ::strcmp;
+  using ::strcoll;
+  using ::strcpy;
+  using ::strcspn;
+  using ::strerror;
+  using ::strlen;
+  using ::strncat;
+  using ::strncmp;
+  using ::strncpy;
+  using ::strspn;
+  using ::strtok;
+  using ::strxfrm;
+  using ::strchr;
+  using ::strpbrk;
+  using ::strrchr;
+  using ::strstr;
+# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+}
+# 63 "/usr/include/boost-1_42/boost/function/function_base.hpp" 2
+# 89 "/usr/include/boost-1_42/boost/function/function_base.hpp"
+namespace boost {
+  namespace detail {
+    namespace function {
+      class X;
+
+
+
+
+
+
+
+      union function_buffer
+      {
+
+        mutable void* obj_ptr;
+
+
+        struct type_t {
+
+          const detail::sp_typeinfo* type;
+
+
+          bool const_qualified;
+
+          bool volatile_qualified;
+        } type;
+
+
+        mutable void (*func_ptr)();
+
+
+        struct bound_memfunc_ptr_t {
+          void (X::*memfunc_ptr)(int);
+          void* obj_ptr;
+        } bound_memfunc_ptr;
+
+
+
+        struct obj_ref_t {
+          mutable void* obj_ptr;
+          bool is_const_qualified;
+          bool is_volatile_qualified;
+        } obj_ref;
+
+
+        mutable char data;
+      };
+
+
+
+
+
+
+
+      struct unusable
+      {
+        unusable() {}
+        template<typename T> unusable(const T&) {}
+      };
+
+
+
+
+
+      template<typename T> struct function_return_type { typedef T type; };
+
+      template<>
+      struct function_return_type<void>
+      {
+        typedef unusable type;
+      };
+
+
+      enum functor_manager_operation_type {
+        clone_functor_tag,
+        move_functor_tag,
+        destroy_functor_tag,
+        check_functor_type_tag,
+        get_functor_type_tag
+      };
+
+
+      struct function_ptr_tag {};
+      struct function_obj_tag {};
+      struct member_ptr_tag {};
+      struct function_obj_ref_tag {};
+
+      template<typename F>
+      class get_function_tag
+      {
+        typedef typename mpl::if_c<(is_pointer<F>::value),
+                                   function_ptr_tag,
+                                   function_obj_tag>::type ptr_or_obj_tag;
+
+        typedef typename mpl::if_c<(is_member_pointer<F>::value),
+                                   member_ptr_tag,
+                                   ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
+
+        typedef typename mpl::if_c<(is_reference_wrapper<F>::value),
+                                   function_obj_ref_tag,
+                                   ptr_or_obj_or_mem_tag>::type or_ref_tag;
+
+      public:
+        typedef or_ref_tag type;
+      };
+
+
+
+      template<typename F>
+      struct reference_manager
+      {
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          switch (op) {
+          case clone_functor_tag:
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            return;
+
+          case move_functor_tag:
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
+            in_buffer.obj_ref.obj_ptr = 0;
+            return;
+
+          case destroy_functor_tag:
+            out_buffer.obj_ref.obj_ptr = 0;
+            return;
+
+          case check_functor_type_tag:
+            {
+              const detail::sp_typeinfo& check_type
+                = *out_buffer.type.type;
+
+
+
+              if ((std::strcmp((check_type).name(),(typeid(F)).name()) == 0)
+                  && (!in_buffer.obj_ref.is_const_qualified
+                      || out_buffer.type.const_qualified)
+                  && (!in_buffer.obj_ref.is_volatile_qualified
+                      || out_buffer.type.volatile_qualified))
+                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
+              else
+                out_buffer.obj_ptr = 0;
+            }
+            return;
+
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(F);
+            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
+            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
+            return;
+          }
+        }
+      };
+
+
+
+
+
+      template<typename F>
+      struct function_allows_small_object_optimization
+      {
+        static const bool value = ((sizeof(F) <= sizeof(function_buffer) && (alignment_of<function_buffer>::value % alignment_of<F>::value == 0)))
+
+
+
+                                                       ;
+      };
+
+      template <typename F,typename A>
+      struct functor_wrapper: public F, public A
+      {
+        functor_wrapper( F f, A a ):
+          F(f),
+          A(a)
+        {
+        }
+
+ functor_wrapper(const functor_wrapper& f) :
+          F(static_cast<const F&>(f)),
+          A(static_cast<const A&>(f))
+ {
+ }
+      };
+
+
+
+
+
+      template<typename Functor>
+      struct functor_manager_common
+      {
+        typedef Functor functor_type;
+
+
+        static inline void
+        manage_ptr(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag)
+            out_buffer.func_ptr = in_buffer.func_ptr;
+          else if (op == move_functor_tag) {
+            out_buffer.func_ptr = in_buffer.func_ptr;
+            in_buffer.func_ptr = 0;
+          } else if (op == destroy_functor_tag)
+            out_buffer.func_ptr = 0;
+          else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = &in_buffer.func_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+
+
+        static inline void
+        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op)
+        {
+          if (op == clone_functor_tag || op == move_functor_tag) {
+            const functor_type* in_functor =
+              reinterpret_cast<const functor_type*>(&in_buffer.data);
+            new ((void*)&out_buffer.data) functor_type(*in_functor);
+
+            if (op == move_functor_tag) {
+              reinterpret_cast<functor_type*>(&in_buffer.data)->~Functor();
+            }
+          } else if (op == destroy_functor_tag) {
+
+            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = &in_buffer.data;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+      };
+
+      template<typename Functor>
+      struct functor_manager
+      {
+      private:
+        typedef Functor functor_type;
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::true_)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::false_)
+        {
+          if (op == clone_functor_tag) {
+
+
+
+            const functor_type* f =
+              (const functor_type*)(in_buffer.obj_ptr);
+            functor_type* new_f = new functor_type(*f);
+            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+
+            functor_type* f =
+              static_cast<functor_type*>(out_buffer.obj_ptr);
+            delete f;
+            out_buffer.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+
+
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, member_ptr_tag)
+        {
+          manager(in_buffer, out_buffer, op, mpl::true_());
+        }
+
+      public:
+
+
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
+            manager(in_buffer, out_buffer, op, tag_type());
+            return;
+          }
+        }
+      };
+
+      template<typename Functor, typename Allocator>
+      struct functor_manager_a
+      {
+      private:
+        typedef Functor functor_type;
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_ptr_tag)
+        {
+          functor_manager_common<Functor>::manage_ptr(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::true_)
+        {
+          functor_manager_common<Functor>::manage_small(in_buffer,out_buffer,op);
+        }
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, mpl::false_)
+        {
+          typedef functor_wrapper<Functor,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+
+          if (op == clone_functor_tag) {
+
+
+
+            const functor_wrapper_type* f =
+              (const functor_wrapper_type*)(in_buffer.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
+            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+            wrapper_allocator.construct(copy, *f);
+
+
+            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
+          } else if (op == destroy_functor_tag) {
+
+            functor_wrapper_type* victim =
+              static_cast<functor_wrapper_type*>(in_buffer.obj_ptr);
+            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*victim));
+            wrapper_allocator.destroy(victim);
+            wrapper_allocator.deallocate(victim,1);
+            out_buffer.obj_ptr = 0;
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if ((std::strcmp((check_type).name(),(typeid(Functor)).name()) == 0))
+              out_buffer.obj_ptr = in_buffer.obj_ptr;
+            else
+              out_buffer.obj_ptr = 0;
+          } else {
+            out_buffer.type.type = &typeid(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+          }
+        }
+
+
+
+
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer,
+                functor_manager_operation_type op, function_obj_tag)
+        {
+          manager(in_buffer, out_buffer, op,
+                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
+        }
+
+      public:
+
+
+        static inline void
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer,
+               functor_manager_operation_type op)
+        {
+          typedef typename get_function_tag<functor_type>::type tag_type;
+          switch (op) {
+          case get_functor_type_tag:
+            out_buffer.type.type = &typeid(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
+            return;
+
+          default:
+            manager(in_buffer, out_buffer, op, tag_type());
+            return;
+          }
+        }
+      };
+
+
+      struct useless_clear_type {};
+# 609 "/usr/include/boost-1_42/boost/function/function_base.hpp"
+      struct vtable_base
+      {
+        void (*manager)(const function_buffer& in_buffer,
+                        function_buffer& out_buffer,
+                        functor_manager_operation_type op);
+      };
+    }
+  }
+
+
+
+
+
+
+
+class function_base
+{
+public:
+  function_base() : vtable(0) { }
+
+
+  bool empty() const { return !vtable; }
+
+
+
+  const detail::sp_typeinfo& target_type() const
+  {
+    if (!vtable) return typeid(void);
+
+    detail::function::function_buffer type;
+    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
+    return *type.type.type;
+  }
+
+  template<typename Functor>
+    Functor* target()
+    {
+      if (!vtable) return 0;
+
+      detail::function::function_buffer type_result;
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = is_const<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result,
+                      detail::function::check_functor_type_tag);
+      return static_cast<Functor*>(type_result.obj_ptr);
+    }
+
+  template<typename Functor>
+
+
+
+    const Functor* target() const
+
+    {
+      if (!vtable) return 0;
+
+      detail::function::function_buffer type_result;
+      type_result.type.type = &typeid(Functor);
+      type_result.type.const_qualified = true;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result,
+                      detail::function::check_functor_type_tag);
+
+
+      return (const Functor*)(type_result.obj_ptr);
+    }
+
+  template<typename F>
+    bool contains(const F& f) const
+    {
+
+
+
+      if (const F* fp = this->template target<F>())
+
+      {
+        return function_equal(*fp, f);
+      } else {
+        return false;
+      }
+    }
+# 715 "/usr/include/boost-1_42/boost/function/function_base.hpp"
+public:
+  detail::function::vtable_base* get_vtable() const {
+    return reinterpret_cast<detail::function::vtable_base*>(
+             reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+  }
+
+  bool has_trivial_copy_and_destroy() const {
+    return reinterpret_cast<std::size_t>(vtable) & 0x01;
+  }
+
+  detail::function::vtable_base* vtable;
+  mutable detail::function::function_buffer functor;
+};
+
+
+
+
+
+class bad_function_call : public std::runtime_error
+{
+public:
+  bad_function_call() : std::runtime_error("call to empty boost::function") {}
+};
+
+
+inline bool operator==(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return f.empty();
+}
+
+inline bool operator!=(const function_base& f,
+                       detail::function::useless_clear_type*)
+{
+  return !f.empty();
+}
+
+inline bool operator==(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return f.empty();
+}
+
+inline bool operator!=(detail::function::useless_clear_type*,
+                       const function_base& f)
+{
+  return !f.empty();
+}
+# 800 "/usr/include/boost-1_42/boost/function/function_base.hpp"
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(*fp, g);
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(g, *fp);
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(*fp, g);
+    else return true;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(g, *fp);
+    else return true;
+  }
+
+
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp == g.get_pointer();
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator==(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() == fp;
+    else return false;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp != g.get_pointer();
+    else return true;
+  }
+
+template<typename Functor>
+  typename ::boost::enable_if_c<(::boost::type_traits::ice_not< (::boost::is_integral<Functor>::value)>::value), bool>::type
+  operator!=(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() != fp;
+    else return true;
+  }
+
+
+
+namespace detail {
+  namespace function {
+    inline bool has_empty_target(const function_base* f)
+    {
+      return f->empty();
+    }
+
+
+
+
+
+
+
+    inline bool has_empty_target(...)
+    {
+      return false;
+    }
+
+  }
+}
+}
+# 18 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mem_fn.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mem_fn.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
+# 1 "/usr/include/boost-1_42/boost/get_pointer.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/get_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/config/no_tr1/memory.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/get_pointer.hpp" 2
+
+namespace boost {
+
+
+
+template<class T> T * get_pointer(T * p)
+{
+    return p;
+}
+
+
+
+template<class T> T * get_pointer(std::auto_ptr<T> const& p)
+{
+    return p.get();
+}
+
+
+}
+# 26 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 2
+
+
+namespace boost
+{
+# 207 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
+namespace _mfi
+{
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/bind/mem_fn_template.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/bind/mem_fn_template.hpp"
+template<class R, class T > class mf0
+{
+public:
+
+    typedef R result_type;
+    typedef T * argument_type;
+
+private:
+
+    typedef R ( T::*F) ();
+    F f_;
+
+    template<class U> R call(U & u, T const *) const
+    {
+        return (u.*f_)();
+    }
+
+    template<class U> R call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_)();
+    }
+
+public:
+
+    explicit mf0(F f): f_(f) {}
+
+    R operator()(T * p) const
+    {
+        return (p->*f_)();
+    }
+
+    template<class U> R operator()(U & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+
+
+
+    template<class U> R operator()(U const & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+
+
+
+    R operator()(T & t) const
+    {
+        return (t.*f_)();
+    }
+
+    bool operator==(mf0 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf0 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T > class cmf0
+{
+public:
+
+    typedef R result_type;
+    typedef T const * argument_type;
+
+private:
+
+    typedef R ( T::*F) () const;
+    F f_;
+
+    template<class U> R call(U & u, T const *) const
+    {
+        return (u.*f_)();
+    }
+
+    template<class U> R call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_)();
+    }
+
+public:
+
+    explicit cmf0(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u) const
+    {
+        U const * p = 0;
+        return call(u, p);
+    }
+
+    R operator()(T const & t) const
+    {
+        return (t.*f_)();
+    }
+
+    bool operator==(cmf0 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf0 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1 > class mf1
+{
+public:
+
+    typedef R result_type;
+    typedef T * first_argument_type;
+    typedef A1 second_argument_type;
+
+private:
+
+    typedef R ( T::*F) (A1);
+    F f_;
+
+    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
+    {
+        return (u.*f_)(b1);
+    }
+
+    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    {
+        return (get_pointer(u)->*f_)(b1);
+    }
+
+public:
+
+    explicit mf1(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1) const
+    {
+        return (p->*f_)(a1);
+    }
+
+    template<class U> R operator()(U & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+
+
+
+    R operator()(T & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+
+    bool operator==(mf1 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf1 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1 > class cmf1
+{
+public:
+
+    typedef R result_type;
+    typedef T const * first_argument_type;
+    typedef A1 second_argument_type;
+
+private:
+
+    typedef R ( T::*F) (A1) const;
+    F f_;
+
+    template<class U, class B1> R call(U & u, T const *, B1 & b1) const
+    {
+        return (u.*f_)(b1);
+    }
+
+    template<class U, class B1> R call(U & u, void const *, B1 & b1) const
+    {
+        return (get_pointer(u)->*f_)(b1);
+    }
+
+public:
+
+    explicit cmf1(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1) const
+    {
+        U const * p = 0;
+        return call(u, p, a1);
+    }
+
+    R operator()(T const & t, A1 a1) const
+    {
+        return (t.*f_)(a1);
+    }
+
+    bool operator==(cmf1 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf1 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2 > class mf2
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2);
+    F f_;
+
+    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
+    {
+        return (u.*f_)(b1, b2);
+    }
+
+    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2);
+    }
+
+public:
+
+    explicit mf2(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2) const
+    {
+        return (p->*f_)(a1, a2);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+
+    bool operator==(mf2 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf2 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2 > class cmf2
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2) const;
+    F f_;
+
+    template<class U, class B1, class B2> R call(U & u, T const *, B1 & b1, B2 & b2) const
+    {
+        return (u.*f_)(b1, b2);
+    }
+
+    template<class U, class B1, class B2> R call(U & u, void const *, B1 & b1, B2 & b2) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2);
+    }
+
+public:
+
+    explicit cmf2(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2) const
+    {
+        return (t.*f_)(a1, a2);
+    }
+
+    bool operator==(cmf2 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf2 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3 > class mf3
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3);
+    F f_;
+
+    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (u.*f_)(b1, b2, b3);
+    }
+
+    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3);
+    }
+
+public:
+
+    explicit mf3(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3) const
+    {
+        return (p->*f_)(a1, a2, a3);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+
+    bool operator==(mf3 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf3 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3 > class cmf3
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (u.*f_)(b1, b2, b3);
+    }
+
+    template<class U, class B1, class B2, class B3> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3);
+    }
+
+public:
+
+    explicit cmf3(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
+    {
+        return (t.*f_)(a1, a2, a3);
+    }
+
+    bool operator==(cmf3 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf3 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4 > class mf4
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (u.*f_)(b1, b2, b3, b4);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
+    }
+
+public:
+
+    explicit mf4(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (p->*f_)(a1, a2, a3, a4);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+
+    bool operator==(mf4 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf4 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4 > class cmf4
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (u.*f_)(b1, b2, b3, b4);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4);
+    }
+
+public:
+
+    explicit cmf4(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
+    {
+        return (t.*f_)(a1, a2, a3, a4);
+    }
+
+    bool operator==(cmf4 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf4 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class mf5
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+    }
+
+public:
+
+    explicit mf5(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+
+    bool operator==(mf5 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf5 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5 > class cmf5
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5);
+    }
+
+public:
+
+    explicit cmf5(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5);
+    }
+
+    bool operator==(cmf5 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf5 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class mf6
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+public:
+
+    explicit mf6(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    bool operator==(mf6 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf6 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6 > class cmf6
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6);
+    }
+
+public:
+
+    explicit cmf6(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6);
+    }
+
+    bool operator==(cmf6 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf6 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class mf7
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+public:
+
+    explicit mf7(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    bool operator==(mf7 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf7 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class cmf7
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7);
+    }
+
+public:
+
+    explicit cmf7(F f): f_(f) {}
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    bool operator==(cmf7 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf7 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class mf8
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8);
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+public:
+
+    explicit mf8(F f): f_(f) {}
+
+    R operator()(T * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+
+
+    R operator()(T & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    bool operator==(mf8 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(mf8 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class cmf8
+{
+public:
+
+    typedef R result_type;
+
+private:
+
+    typedef R ( T::*F) (A1, A2, A3, A4, A5, A6, A7, A8) const;
+    F f_;
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, T const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (u.*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+    template<class U, class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8> R call(U & u, void const *, B1 & b1, B2 & b2, B3 & b3, B4 & b4, B5 & b5, B6 & b6, B7 & b7, B8 & b8) const
+    {
+        return (get_pointer(u)->*f_)(b1, b2, b3, b4, b5, b6, b7, b8);
+    }
+
+public:
+
+    explicit cmf8(F f): f_(f) {}
+
+    R operator()(T const * p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (p->*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        U const * p = 0;
+        return call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
+    {
+        return (t.*f_)(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    bool operator==(cmf8 const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(cmf8 const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+# 216 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 2
+# 258 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
+}
+# 268 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind/mem_fn_cc.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/bind/mem_fn_cc.hpp"
+template<class R, class T> _mfi::mf0<R, T> mem_fn(R ( T::*f) ())
+{
+    return _mfi::mf0<R, T>(f);
+}
+
+template<class R, class T> _mfi::cmf0<R, T> mem_fn(R ( T::*f) () const)
+{
+    return _mfi::cmf0<R, T>(f);
+}
+
+template<class R, class T, class A1> _mfi::mf1<R, T, A1> mem_fn(R ( T::*f) (A1))
+{
+    return _mfi::mf1<R, T, A1>(f);
+}
+
+template<class R, class T, class A1> _mfi::cmf1<R, T, A1> mem_fn(R ( T::*f) (A1) const)
+{
+    return _mfi::cmf1<R, T, A1>(f);
+}
+
+template<class R, class T, class A1, class A2> _mfi::mf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2))
+{
+    return _mfi::mf2<R, T, A1, A2>(f);
+}
+
+template<class R, class T, class A1, class A2> _mfi::cmf2<R, T, A1, A2> mem_fn(R ( T::*f) (A1, A2) const)
+{
+    return _mfi::cmf2<R, T, A1, A2>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3> _mfi::mf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3))
+{
+    return _mfi::mf3<R, T, A1, A2, A3>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3> _mfi::cmf3<R, T, A1, A2, A3> mem_fn(R ( T::*f) (A1, A2, A3) const)
+{
+    return _mfi::cmf3<R, T, A1, A2, A3>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::mf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4))
+{
+    return _mfi::mf4<R, T, A1, A2, A3, A4>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4> _mfi::cmf4<R, T, A1, A2, A3, A4> mem_fn(R ( T::*f) (A1, A2, A3, A4) const)
+{
+    return _mfi::cmf4<R, T, A1, A2, A3, A4>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::mf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5))
+{
+    return _mfi::mf5<R, T, A1, A2, A3, A4, A5>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5> _mfi::cmf5<R, T, A1, A2, A3, A4, A5> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5) const)
+{
+    return _mfi::cmf5<R, T, A1, A2, A3, A4, A5>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6))
+{
+    return _mfi::mf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6> _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6) const)
+{
+    return _mfi::cmf6<R, T, A1, A2, A3, A4, A5, A6>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7))
+{
+    return _mfi::mf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7) const)
+{
+    return _mfi::cmf7<R, T, A1, A2, A3, A4, A5, A6, A7>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8))
+{
+    return _mfi::mf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}
+
+template<class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8> mem_fn(R ( T::*f) (A1, A2, A3, A4, A5, A6, A7, A8) const)
+{
+    return _mfi::cmf8<R, T, A1, A2, A3, A4, A5, A6, A7, A8>(f);
+}
+# 269 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp" 2
+# 311 "/usr/include/boost-1_42/boost/bind/mem_fn.hpp"
+namespace _mfi
+{
+
+template<class R, class T> class dm
+{
+public:
+
+    typedef R const & result_type;
+    typedef T const * argument_type;
+
+private:
+
+    typedef R (T::*F);
+    F f_;
+
+    template<class U> R const & call(U & u, T const *) const
+    {
+        return (u.*f_);
+    }
+
+    template<class U> R const & call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_);
+    }
+
+public:
+
+    explicit dm(F f): f_(f) {}
+
+    R & operator()(T * p) const
+    {
+        return (p->*f_);
+    }
+
+    R const & operator()(T const * p) const
+    {
+        return (p->*f_);
+    }
+
+    template<class U> R const & operator()(U const & u) const
+    {
+        return call(u, &u);
+    }
+
+
+
+    R & operator()(T & t) const
+    {
+        return (t.*f_);
+    }
+
+    R const & operator()(T const & t) const
+    {
+        return (t.*f_);
+    }
+
+
+
+    bool operator==(dm const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(dm const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+}
+
+template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
+{
+    return _mfi::dm<R, T>(f);
+}
+
+}
+# 23 "/usr/include/boost-1_42/boost/mem_fn.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/enum.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/enum.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/rem.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/preprocessor/enum.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/enum_params.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/enum_params.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/enum_params.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/function/detail/prologue.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/function/function_template.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/detail/no_exceptions_support.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/function/function_template.hpp" 2
+# 81 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R
+       
+        >
+      struct function_invoker0
+      {
+        static R invoke(function_buffer& function_ptr
+                        )
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f();
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R
+       
+        >
+      struct void_function_invoker0
+      {
+        static void
+        invoke(function_buffer& function_ptr
+               )
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct function_obj_invoker0
+      {
+        static R invoke(function_buffer& function_obj_ptr
+                        )
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct void_function_obj_invoker0
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr
+               )
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct function_ref_invoker0
+      {
+        static R invoke(function_buffer& function_obj_ptr
+                        )
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)();
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+      >
+      struct void_function_ref_invoker0
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr
+               )
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)();
+        }
+      };
+# 230 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+      template<
+        typename FunctionPtr,
+        typename R
+       
+      >
+      struct get_function_invoker0
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker0<
+                            FunctionPtr,
+                            R
+                           
+                          >,
+                          function_invoker0<
+                            FunctionPtr,
+                            R
+                           
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+       >
+      struct get_function_obj_invoker0
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >,
+                          function_obj_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R
+       
+       >
+      struct get_function_ref_invoker0
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >,
+                          function_ref_invoker0<
+                            FunctionObj,
+                            R
+                           
+                          >
+                       >::type type;
+      };
+# 326 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+      template<typename Tag>
+      struct get_invoker0 { };
+
+
+      template<>
+      struct get_invoker0<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_invoker0<
+                             FunctionPtr,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr,
+                 typename R ,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker0<
+                             FunctionPtr,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+# 400 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+      template<>
+      struct get_invoker0<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_obj_invoker0<
+                             FunctionObj,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj,
+                 typename R ,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker0<
+                             FunctionObj,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker0<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R >
+        struct apply
+        {
+          typedef typename get_function_ref_invoker0<
+                             typename RefWrapper::type,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper,
+                 typename R ,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker0<
+                             typename RefWrapper::type,
+                             R
+                            
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 475 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+      template<typename R >
+      struct basic_vtable0
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                           
+                                            );
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor)
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a)
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor)
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.func_ptr = (void (*)())(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+# 562 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
+        {
+          new ((void*)&functor.data) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag)
+        {
+          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag)
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R
+   
+  >
+  class function0 : public function_base
+# 664 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable0<
+              R >
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 0;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+# 702 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+    static const int arity = 0;
+   
+
+    typedef function0 self_type;
+
+    function0() : function_base() { }
+
+
+
+    template<typename Functor>
+    function0(Functor f
+
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function0(Functor f, Allocator a
+
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function0(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function0(const function0& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+    ~function0() { clear(); }
+# 766 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+    result_type operator()() const;
+
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function0&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function0& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 824 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+    function0& operator=(const function0& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+    void swap(function0& other)
+    {
+      if (&other == this)
+        return;
+
+      function0 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {};
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function0& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker0<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R
+                        >
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= (std::size_t)0x01;
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker0<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R
+                         ,
+                         Allocator>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= (std::size_t)0x01;
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function0& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R >
+  inline void swap(function0<
+                     R
+                    
+                   >& f1,
+                   function0<
+                     R
+                    
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+  template<typename R >
+  typename function0<
+      R >::result_type
+  inline
+  function0<R >
+  ::operator()() const
+  {
+    if (this->empty())
+      boost::throw_exception(bad_function_call());
+
+    return get_vtable()->invoker
+             (this->functor );
+  }
+
+
+
+template<typename R >
+  void operator==(const function0<
+                          R
+                          >&,
+                  const function0<
+                          R
+                          >&);
+template<typename R >
+  void operator!=(const function0<
+                          R
+                          >&,
+                  const function0<
+                          R
+                          >& );
+# 1041 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+template<typename R
+         >
+class function<R (void)>
+  : public function0<R >
+{
+  typedef function0<R > base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() : base_type() {}
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+  template<typename Functor>
+
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+
+
+
+
+}
+# 14 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 2
+# 12 "/usr/include/boost-1_42/boost/function/function0.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/python/errors.hpp" 2
+
+namespace boost { namespace python {
+
+struct __attribute__ ((visibility("default"))) error_already_set
+{
+  virtual ~error_already_set();
+};
+
+
+
+ bool handle_exception_impl(function0<void>);
+
+template <class T>
+bool handle_exception(T f)
+{
+    return handle_exception_impl(function0<void>(boost::ref(f)));
+}
+
+namespace detail { inline void rethrow() { throw; } }
+
+inline void handle_exception()
+{
+    handle_exception(detail::rethrow);
+}
+
+ void throw_error_already_set();
+
+template <class T>
+inline T* expect_non_null(T* x)
+{
+    if (x == 0)
+        throw_error_already_set();
+    return x;
+}
+
+
+
+ PyObject* pytype_check(PyTypeObject* pytype, PyObject* source);
+
+}}
+# 12 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/borrowed.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/borrowed.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_assign_impl
+{
+   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_assign(T) >::value, ::boost::type_traits::ice_not< ::boost::is_const<T>::value >::value, ::boost::type_traits::ice_not< ::boost::is_volatile<T>::value >::value >::value)
+
+
+
+
+
+
+
+                ;
+};
+
+}
+
+template< typename T > struct has_trivial_assign : ::boost::integral_constant<bool,::boost::detail::has_trivial_assign_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 49 "/usr/include/boost-1_42/boost/type_traits/has_trivial_assign.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct has_trivial_ctor_impl
+{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::is_pod<T>::value, __has_trivial_constructor(T) >::value)
+
+
+
+                ;
+};
+
+}
+
+template< typename T > struct has_trivial_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };
+template< typename T > struct has_trivial_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_trivial_ctor_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 42 "/usr/include/boost-1_42/boost/type_traits/has_trivial_constructor.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp" 2
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_constructor_imp{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_constructor<T>::value, __has_nothrow_constructor(T) >::value)
+
+
+
+                ;
+};
+
+}
+
+template< typename T > struct has_nothrow_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };
+template< typename T > struct has_nothrow_default_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_constructor_imp<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 38 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_constructor.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp" 2
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_copy_imp{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_copy<T>::value, (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value) >::value)
+
+
+
+                ;
+};
+
+}
+
+template< typename T > struct has_nothrow_copy : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };
+template< typename T > struct has_nothrow_copy_constructor : ::boost::integral_constant<bool,::boost::detail::has_nothrow_copy_imp<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 38 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_copy.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp" 2
+
+namespace boost {
+
+namespace detail{
+
+template <class T>
+struct has_nothrow_assign_imp{
+   static const bool value = (::boost::type_traits::ice_or< ::boost::has_trivial_assign<T>::value, (__has_nothrow_assign(T) && !is_volatile<T>::value) >::value)
+
+
+
+                ;
+};
+
+}
+
+template< typename T > struct has_nothrow_assign : ::boost::integral_constant<bool,::boost::detail::has_nothrow_assign_imp<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_assign.hpp" 2
+# 24 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp" 2
+
+namespace boost {
+
+namespace detail {
+# 222 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp"
+template <typename B, typename D>
+struct is_base_and_derived_impl
+{
+    typedef typename remove_cv<B>::type ncvB;
+    typedef typename remove_cv<D>::type ncvD;
+
+    static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
+};
+
+}
+
+template< typename Base, typename Derived > struct is_base_and_derived : ::boost::integral_constant<bool,(::boost::detail::is_base_and_derived_impl<Base,Derived>::value)> { };
+
+
+
+
+
+
+
+template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_and_derived< Base,Derived& > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_and_derived< Base&,Derived& > : ::boost::integral_constant<bool,false> { };
+
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 253 "/usr/include/boost-1_42/boost/type_traits/is_base_and_derived.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 38 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp" 2
+
+namespace boost {
+
+namespace detail {
+# 120 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp"
+template <typename T>
+struct is_class_impl
+{
+    static const bool value = __is_class(T);
+};
+
+
+}
+
+
+
+
+
+template< typename T > struct is_class : ::boost::integral_constant<bool,::boost::detail::is_class_impl<T>::value> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 139 "/usr/include/boost-1_42/boost/type_traits/is_class.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_fundamental_impl
+    : ::boost::type_traits::ice_or<
+          ::boost::is_arithmetic<T>::value
+        , ::boost::is_void<T>::value
+        >
+{
+};
+
+}
+
+
+
+
+
+template< typename T > struct is_fundamental : ::boost::integral_constant<bool,::boost::detail::is_fundamental_impl<T>::value> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 44 "/usr/include/boost-1_42/boost/type_traits/is_fundamental.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 2
+
+namespace boost {
+
+
+namespace detail {
+
+template <typename T>
+struct is_compound_impl
+{
+   static const bool value = (::boost::type_traits::ice_not< ::boost::is_fundamental<T>::value >::value)
+
+
+                 ;
+};
+
+}
+
+
+
+
+
+template< typename T > struct is_compound : ::boost::integral_constant<bool,::boost::detail::is_compound_impl<T>::value> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 45 "/usr/include/boost-1_42/boost/type_traits/is_compound.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp" 2
+
+namespace boost {
+
+namespace detail {
+# 55 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp"
+template <typename T>
+struct add_reference_impl
+{
+    typedef T& type;
+};
+
+
+template< typename T > struct add_reference_impl<T&> { typedef T& type; };
+
+
+
+
+
+template<> struct add_reference_impl<void> { typedef void type; };
+
+template<> struct add_reference_impl<void const> { typedef void const type; };
+template<> struct add_reference_impl<void volatile> { typedef void volatile type; };
+template<> struct add_reference_impl<void const volatile> { typedef void const volatile type; };
+
+
+}
+
+template< typename T > struct add_reference { typedef typename boost::detail::add_reference_impl<T>::type type; };
+
+
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 88 "/usr/include/boost-1_42/boost/type_traits/add_reference.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp" 1
+# 62 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 63 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp" 2
+
+
+namespace boost {
+namespace detail{
+
+
+template <class T>
+struct is_abstract_imp
+{
+   static const bool value = __is_abstract(T);
+};
+# 141 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp"
+}
+
+
+template< typename T > struct is_abstract : ::boost::integral_constant<bool,::boost::detail::is_abstract_imp<T>::value> { };
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 152 "/usr/include/boost-1_42/boost/type_traits/is_abstract.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2
+
+namespace boost {
+# 52 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+namespace detail {
+# 119 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+struct any_conversion
+{
+    template <typename T> any_conversion(const volatile T&);
+    template <typename T> any_conversion(T&);
+};
+
+template <typename T> struct checker
+{
+    static boost::type_traits::no_type _m_check(any_conversion ...);
+    static boost::type_traits::yes_type _m_check(T, int);
+};
+
+template <typename From, typename To>
+struct is_convertible_basic_impl
+{
+    static From _m_from;
+    static bool const value = sizeof( detail::checker<To>::_m_check(_m_from, 0) )
+        == sizeof(::boost::type_traits::yes_type);
+};
+# 291 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+template <typename From, typename To>
+struct is_convertible_impl
+{
+    typedef typename add_reference<From>::type ref_type;
+    static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_or< ::boost::detail::is_convertible_basic_impl<ref_type,To>::value, ::boost::is_void<To>::value >::value, ::boost::type_traits::ice_not< ::boost::is_array<To>::value >::value >::value)
+# 305 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+         ;
+};
+
+
+template <bool trivial1, bool trivial2, bool abstract_target>
+struct is_convertible_impl_select
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef is_convertible_impl<From, To> type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<true, true, false>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef true_type type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<false, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <>
+struct is_convertible_impl_select<true, false, true>
+{
+   template <class From, class To>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch_base
+{
+
+   typedef is_convertible_impl_select<
+      ::boost::is_arithmetic<From>::value,
+      ::boost::is_arithmetic<To>::value,
+
+      ::boost::is_abstract<To>::value
+
+
+
+   > selector;
+
+
+
+   typedef typename selector::template rebind<From, To> isc_binder;
+   typedef typename isc_binder::type type;
+};
+
+template <typename From, typename To>
+struct is_convertible_impl_dispatch
+   : public is_convertible_impl_dispatch_base<From, To>::type
+{};
+# 394 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+    template<> struct is_convertible_impl< void,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void volatile,void const volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void volatile > { static const bool value = (true); }; template<> struct is_convertible_impl< void const volatile,void const volatile > { static const bool value = (true); };
+# 404 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp"
+template< typename To > struct is_convertible_impl< void,To > { static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void > { static const bool value = (true); };
+
+template< typename To > struct is_convertible_impl< void const,To > { static const bool value = (false); };
+template< typename To > struct is_convertible_impl< void volatile,To > { static const bool value = (false); };
+template< typename To > struct is_convertible_impl< void const volatile,To > { static const bool value = (false); };
+template< typename From > struct is_convertible_impl< From,void const > { static const bool value = (true); };
+template< typename From > struct is_convertible_impl< From,void volatile > { static const bool value = (true); };
+template< typename From > struct is_convertible_impl< From,void const volatile > { static const bool value = (true); };
+
+
+
+}
+
+template< typename From, typename To > struct is_convertible : ::boost::integral_constant<bool,(::boost::detail::is_convertible_impl_dispatch<From,To>::value)> { };
+
+
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 429 "/usr/include/boost-1_42/boost/type_traits/is_convertible.hpp" 2
+# 13 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+
+template <typename T>
+struct empty_helper_t1 : public T
+{
+    empty_helper_t1();
+    int i[256];
+private:
+
+   empty_helper_t1(const empty_helper_t1&);
+   empty_helper_t1& operator=(const empty_helper_t1&);
+};
+
+struct empty_helper_t2 { int i[256]; };
+
+
+
+template <typename T, bool is_a_class = false>
+struct empty_helper
+{
+    static const bool value = false;
+};
+
+template <typename T>
+struct empty_helper<T, true>
+{
+    static const bool value = (sizeof(empty_helper_t1<T>) == sizeof(empty_helper_t2))
+
+         ;
+};
+
+template <typename T>
+struct is_empty_impl
+{
+    typedef typename remove_cv<T>::type cvt;
+    static const bool value = ( ::boost::type_traits::ice_or< ::boost::detail::empty_helper<cvt,::boost::is_class<T>::value>::value , __is_empty(cvt) >::value )
+
+
+
+
+
+              ;
+};
+# 195 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp"
+template<> struct is_empty_impl< void > { static const bool value = (false); };
+
+template<> struct is_empty_impl< void const > { static const bool value = (false); };
+template<> struct is_empty_impl< void volatile > { static const bool value = (false); };
+template<> struct is_empty_impl< void const volatile > { static const bool value = (false); };
+
+
+}
+
+template< typename T > struct is_empty : ::boost::integral_constant<bool,::boost::detail::is_empty_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 209 "/usr/include/boost-1_42/boost/type_traits/is_empty.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/false_result.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/false_result.hpp"
+namespace boost {
+namespace type_traits {
+
+
+struct false_result
+{
+    template <typename T> struct result_
+    {
+        static const bool value = false;
+    };
+};
+
+}}
+# 16 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/is_function_ptr_helper.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/type_traits/detail/is_function_ptr_helper.hpp"
+namespace boost {
+namespace type_traits {
+
+template <class R>
+struct is_function_ptr_helper
+{
+    static const bool value = false;
+};
+
+
+
+
+template <class R >
+struct is_function_ptr_helper<R (*)()> { static const bool value = true; };
+
+template <class R >
+struct is_function_ptr_helper<R (*)( ...)> { static const bool value = true; };
+
+template <class R , class T0>
+struct is_function_ptr_helper<R (*)( T0)> { static const bool value = true; };
+
+template <class R , class T0>
+struct is_function_ptr_helper<R (*)( T0 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1>
+struct is_function_ptr_helper<R (*)( T0 , T1)> { static const bool value = true; };
+
+template <class R , class T0 , class T1>
+struct is_function_ptr_helper<R (*)( T0 , T1 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 ...)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24)> { static const bool value = true; };
+
+template <class R , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15 , class T16 , class T17 , class T18 , class T19 , class T20 , class T21 , class T22 , class T23 , class T24>
+struct is_function_ptr_helper<R (*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 ...)> { static const bool value = true; };
+# 203 "/usr/include/boost-1_42/boost/type_traits/detail/is_function_ptr_helper.hpp"
+}
+}
+# 20 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2
+
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail {
+
+
+template<bool is_ref = true>
+struct is_function_chooser
+    : ::boost::type_traits::false_result
+{
+};
+
+template <>
+struct is_function_chooser<false>
+{
+    template< typename T > struct result_
+        : ::boost::type_traits::is_function_ptr_helper<T*>
+    {
+    };
+};
+
+template <typename T>
+struct is_function_impl
+    : is_function_chooser< ::boost::is_reference<T>::value >
+        ::template result_<T>
+{
+};
+# 90 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp"
+}
+
+
+
+
+
+
+template< typename T > struct is_function : ::boost::integral_constant<bool,::boost::detail::is_function_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 102 "/usr/include/boost-1_42/boost/type_traits/is_function.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_object_impl
+{
+
+   static const bool value = (::boost::type_traits::ice_and< ::boost::type_traits::ice_not< ::boost::is_reference<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_void<T>::value>::value, ::boost::type_traits::ice_not< ::boost::is_function<T>::value>::value >::value)
+
+
+
+
+                ;
+
+
+
+
+
+
+
+};
+
+}
+
+template< typename T > struct is_object : ::boost::integral_constant<bool,::boost::detail::is_object_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 52 "/usr/include/boost-1_42/boost/type_traits/is_object.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <typename T>
+struct is_stateless_impl
+{
+  static const bool value = (::boost::type_traits::ice_and< ::boost::has_trivial_constructor<T>::value, ::boost::has_trivial_copy<T>::value, ::boost::has_trivial_destructor<T>::value, ::boost::is_class<T>::value, ::boost::is_empty<T>::value >::value)
+
+
+
+
+
+
+               ;
+};
+
+}
+
+template< typename T > struct is_stateless : ::boost::integral_constant<bool,::boost::detail::is_stateless_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/type_traits/is_stateless.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/type_traits/object_traits.hpp" 2
+# 12 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/tag.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/tag.hpp"
+namespace boost { namespace python {
+
+
+
+enum tag_t { tag };
+
+}}
+# 14 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+template<class T> class borrowed
+{
+    typedef T type;
+};
+
+
+template<typename T>
+struct is_borrowed_ptr
+{
+    static const bool value = false;
+};
+
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T>*>
+{
+    static const bool value = true;
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> const*>
+{
+    static const bool value = true;
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> volatile*>
+{
+    static const bool value = true;
+};
+
+template<typename T>
+struct is_borrowed_ptr<borrowed<T> const volatile*>
+{
+    static const bool value = true;
+};
+# 101 "/usr/include/boost-1_42/boost/python/detail/borrowed_ptr.hpp"
+}
+
+template <class T>
+inline T* get_managed_object(detail::borrowed<T> const volatile* p, tag_t)
+{
+    return (T*)p;
+}
+
+}}
+# 10 "/usr/include/boost-1_42/boost/python/borrowed.hpp" 2
+
+namespace boost { namespace python {
+
+template <class T>
+inline python::detail::borrowed<T>* borrowed(T* p)
+{
+    return (detail::borrowed<T>*)p;
+}
+
+}}
+# 13 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/handle_fwd.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/handle_fwd.hpp"
+namespace boost { namespace python {
+
+template <class T = PyObject> class handle;
+
+}}
+# 14 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/refcount.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/refcount.hpp"
+namespace boost { namespace python {
+
+template <class T>
+inline T* incref(T* p)
+{
+    ( ((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt++);
+    return p;
+}
+
+template <class T>
+inline T* xincref(T* p)
+{
+    if ((python::upcast<PyObject>(p)) == __null) ; else ( ((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt++);
+    return p;
+}
+
+template <class T>
+inline void decref(T* p)
+{
+    if ( --((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(python::upcast<PyObject>(p))))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(python::upcast<PyObject>(p)))));
+}
+
+template <class T>
+inline void xdecref(T* p)
+{
+    if ((python::upcast<PyObject>(p)) == __null) ; else if ( --((PyObject*)(python::upcast<PyObject>(p)))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(python::upcast<PyObject>(p))))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(python::upcast<PyObject>(p)))));
+}
+
+}}
+# 15 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/raw_pyobject.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+# 19 "/usr/include/boost-1_42/boost/python/detail/raw_pyobject.hpp"
+struct new_reference_t;
+typedef new_reference_t* new_reference;
+
+
+struct borrowed_reference_t;
+typedef borrowed_reference_t* borrowed_reference;
+
+
+struct new_non_null_reference_t;
+typedef new_non_null_reference_t* new_non_null_reference;
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/handle.hpp" 2
+
+namespace boost { namespace python {
+
+template <class T> struct null_ok;
+
+template <class T>
+inline null_ok<T>* allow_null(T* p)
+{
+    return (null_ok<T>*)p;
+}
+
+namespace detail
+{
+  template <class T>
+  inline T* manage_ptr(detail::borrowed<null_ok<T> >* p, int)
+  {
+      return python::xincref((T*)p);
+  }
+
+  template <class T>
+  inline T* manage_ptr(null_ok<detail::borrowed<T> >* p, int)
+  {
+      return python::xincref((T*)p);
+  }
+
+  template <class T>
+  inline T* manage_ptr(detail::borrowed<T>* p, long)
+  {
+      return python::incref(expect_non_null((T*)p));
+  }
+
+  template <class T>
+  inline T* manage_ptr(null_ok<T>* p, long)
+  {
+      return (T*)p;
+  }
+
+  template <class T>
+  inline T* manage_ptr(T* p, ...)
+  {
+      return expect_non_null(p);
+  }
+}
+
+template <class T>
+class handle
+{
+    typedef T* (handle::* bool_type )() const;
+
+ public:
+    typedef T element_type;
+
+ public:
+    handle();
+    ~handle();
+
+    template <class Y>
+    explicit handle(Y* p)
+        : m_p(
+            python::upcast<T>(
+                detail::manage_ptr(p, 0)
+                )
+            )
+    {
+    }
+
+    handle& operator=(handle const& r)
+    {
+        python::xdecref(m_p);
+        m_p = python::xincref(r.m_p);
+        return *this;
+    }
+
+
+
+    template<typename Y>
+    handle& operator=(handle<Y> const & r)
+    {
+        python::xdecref(m_p);
+        m_p = python::xincref(python::upcast<T>(r.get()));
+        return *this;
+    }
+
+
+
+    template <typename Y>
+    handle(handle<Y> const& r)
+        : m_p(python::xincref(python::upcast<T>(r.get())))
+    {
+    }
+
+    handle(handle const& r)
+        : m_p(python::xincref(r.m_p))
+    {
+    }
+
+    T* operator-> () const;
+    T& operator* () const;
+    T* get() const;
+    T* release();
+    void reset();
+
+    operator bool_type() const
+    {
+        return m_p ? &handle<T>::get : 0;
+    }
+    bool operator! () const;
+
+ public:
+
+    inline handle(detail::borrowed_reference x)
+        : m_p(
+            python::incref(
+                downcast<T>((PyObject*)x)
+                ))
+    {
+    }
+
+ private:
+    T* m_p;
+};
+
+
+
+
+
+template<class T> inline T * get_pointer(python::handle<T> const & p)
+{
+    return p.get();
+}
+
+
+
+
+
+
+using boost::get_pointer;
+
+
+
+typedef handle<PyTypeObject> type_handle;
+
+
+
+
+
+template<typename T>
+class is_handle
+{
+ public:
+    static const bool value = false;
+};
+
+template<typename T>
+class is_handle<handle<T> >
+{
+ public:
+    static const bool value = true;
+};
+# 202 "/usr/include/boost-1_42/boost/python/handle.hpp"
+template <class T>
+inline handle<T>::handle()
+    : m_p(0)
+{
+}
+
+template <class T>
+inline handle<T>::~handle()
+{
+    python::xdecref(m_p);
+}
+
+template <class T>
+inline T* handle<T>::operator->() const
+{
+    return m_p;
+}
+
+template <class T>
+inline T& handle<T>::operator*() const
+{
+    return *m_p;
+}
+
+template <class T>
+inline T* handle<T>::get() const
+{
+    return m_p;
+}
+
+template <class T>
+inline bool handle<T>::operator!() const
+{
+    return m_p == 0;
+}
+
+template <class T>
+inline T* handle<T>::release()
+{
+    T* result = m_p;
+    m_p = 0;
+    return result;
+}
+
+template <class T>
+inline void handle<T>::reset()
+{
+    python::xdecref(m_p);
+    m_p = 0;
+}
+
+
+
+template <class T>
+inline PyObject* get_managed_object(handle<T> const& h, tag_t)
+{
+    return h.get() ? python::upcast<PyObject>(h.get()) : (&_Py_NoneStruct);
+}
+
+}}
+# 11 "/usr/include/boost-1_42/boost/python/args_fwd.hpp" 2
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 13 "/usr/include/boost-1_42/boost/python/args_fwd.hpp" 2
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  struct keyword
+  {
+      keyword(char const* name_=0)
+       : name(name_)
+      {}
+
+      char const* name;
+      handle<> default_value;
+  };
+
+  template <std::size_t nkeywords = 0> struct keywords;
+
+  typedef std::pair<keyword const*, keyword const*> keyword_range;
+
+  template <>
+  struct keywords<0>
+  {
+      static const std::size_t size = 0;
+      static keyword_range range() { return keyword_range(); }
+  };
+
+  namespace error
+  {
+    template <int keywords, int function_args>
+    struct more_keywords_than_function_arguments
+    {
+        typedef char too_many_keywords[keywords > function_args ? -1 : 1];
+    };
+  }
+}
+
+}}
+# 11 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/preprocessor.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/at_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/at_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct at_impl;
+template< typename Sequence, typename N > struct at;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/tag.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/tag.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/typeof.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/tag.hpp" 2
+
+
+namespace boost { namespace mpl { namespace aux {
+
+struct v_iter_tag;
+
+
+struct vector_tag;
+
+
+
+
+}}}
+# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/long.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/long.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/long_fwd.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/long_fwd.hpp"
+namespace mpl_ {
+
+template< long N > struct long_;
+
+}
+namespace boost { namespace mpl { using ::mpl_::long_; } }
+# 18 "/usr/include/boost-1_42/boost/mpl/long.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp" 1
+# 40 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+namespace mpl_ {
+
+template< long N >
+struct long_
+{
+    static const long value = N;
+
+
+
+
+
+    typedef long_ type;
+
+    typedef long value_type;
+    typedef integral_c_tag tag;
+# 72 "/usr/include/boost-1_42/boost/mpl/aux_/integral_wrapper.hpp"
+    typedef mpl_::long_< static_cast<long>((value + 1)) > next;
+    typedef mpl_::long_< static_cast<long>((value - 1)) > prior;
+
+
+
+
+
+
+    operator long() const { return static_cast<long>(this->value); }
+};
+
+
+template< long N >
+long const mpl_::long_< N >::value;
+
+
+}
+# 21 "/usr/include/boost-1_42/boost/mpl/long.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/void.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/void.hpp"
+namespace mpl_ {
+
+
+
+
+
+struct void_ { typedef void_ type; };
+
+}
+
+namespace boost { namespace mpl {
+
+template< typename T >
+struct is_void_
+    : false_
+{
+
+
+
+};
+
+template<>
+struct is_void_<void_>
+    : true_
+{
+
+
+
+};
+
+template< typename T >
+struct is_not_void_
+    : true_
+{
+
+
+
+};
+
+template<>
+struct is_not_void_<void_>
+    : false_
+{
+
+
+
+};
+
+template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
+template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }
+
+}}
+# 21 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/type_wrapper.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/type_wrapper.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct type_wrapper
+{
+    typedef T type;
+};
+
+
+
+
+
+
+template< typename T > struct wrapped_type;
+
+template< typename T > struct wrapped_type< type_wrapper<T> >
+{
+    typedef T type;
+};
+
+
+
+
+
+
+
+}}}
+# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template< typename Vector, long n_ >
+struct v_at_impl
+{
+    typedef long_< (Vector::lower_bound_::value + n_) > index_;
+    typedef __typeof__( Vector::item_(index_()) ) type;
+};
+
+
+template< typename Vector, long n_ >
+struct v_at
+    : aux::wrapped_type< typename v_at_impl<Vector,n_>::type >
+{
+};
+
+template<>
+struct at_impl< aux::vector_tag >
+{
+    template< typename Vector, typename N > struct apply
+        : v_at<
+              Vector
+            , N::value
+            >
+    {
+    };
+};
+# 114 "/usr/include/boost-1_42/boost/mpl/vector/aux_/at.hpp"
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/front_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/front_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct front_impl;
+template< typename Sequence > struct front;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<>
+struct front_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : v_at<Vector,0>
+    {
+    };
+};
+# 54 "/usr/include/boost-1_42/boost/mpl/vector/aux_/front.hpp"
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/push_front_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/push_front_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct push_front_impl;
+template< typename Sequence, typename T > struct push_front;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/item.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/item.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/next_prior.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/next_prior.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/common_name_wknd.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/next_prior.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+
+
+
+template<
+      typename T = na
+    >
+struct next
+{
+    typedef typename T::next type;
+   
+};
+
+template<
+      typename T = na
+    >
+struct prior
+{
+    typedef typename T::prior type;
+   
+};
+
+template<> struct next< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : next< T1 > { }; }; template< typename Tag > struct lambda< next< na > , Tag , int_<-1> > { typedef false_ is_le; typedef next< na > result_; typedef next< na > type; }; namespace aux { template< typename T1 > struct template_arity< next< T1 > > : int_<1> { }; template<> struct template_arity< next< na > > : int_<-1> { }; }
+template<> struct prior< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : prior< T1 > { }; }; template< typename Tag > struct lambda< prior< na > , Tag , int_<-1> > { typedef false_ is_le; typedef prior< na > result_; typedef prior< na > type; }; namespace aux { template< typename T1 > struct template_arity< prior< T1 > > : int_<1> { }; template<> struct template_arity< prior< na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/vector/aux_/item.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<
+      typename T
+    , typename Base
+    , int at_front = 0
+    >
+struct v_item
+    : Base
+{
+    typedef typename Base::upper_bound_ index_;
+    typedef typename next<index_>::type upper_bound_;
+    typedef typename next<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_item type;
+
+
+
+    static aux::type_wrapper<T> item_(index_);
+    using Base::item_;
+};
+
+template<
+      typename T
+    , typename Base
+    >
+struct v_item<T,Base,1>
+    : Base
+{
+    typedef typename prior<typename Base::lower_bound_>::type index_;
+    typedef index_ lower_bound_;
+    typedef typename next<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_item type;
+
+    static aux::type_wrapper<T> item_(index_);
+    using Base::item_;
+};
+
+
+template<
+      typename Base
+    , int at_front
+    >
+struct v_mask
+    : Base
+{
+    typedef typename prior<typename Base::upper_bound_>::type index_;
+    typedef index_ upper_bound_;
+    typedef typename prior<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_mask type;
+
+    static aux::type_wrapper<void_> item_(index_);
+    using Base::item_;
+};
+
+template<
+      typename Base
+    >
+struct v_mask<Base,1>
+    : Base
+{
+    typedef typename Base::lower_bound_ index_;
+    typedef typename next<index_>::type lower_bound_;
+    typedef typename prior<typename Base::size>::type size;
+    typedef Base base;
+    typedef v_mask type;
+
+    static aux::type_wrapper<void_> item_(index_);
+    using Base::item_;
+};
+
+
+
+}}
+# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_front.hpp" 2
+
+
+namespace boost { namespace mpl {
+
+template<>
+struct push_front_impl< aux::vector_tag >
+{
+    template< typename Vector, typename T > struct apply
+    {
+        typedef v_item<T,Vector,1> type;
+    };
+};
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_front.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_front.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/pop_front_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/pop_front_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct pop_front_impl;
+template< typename Sequence > struct pop_front;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_front.hpp" 2
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<>
+struct pop_front_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_mask<Vector,1> type;
+    };
+};
+
+}}
+# 21 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_back.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_back.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/push_back_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/push_back_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct push_back_impl;
+template< typename Sequence, typename T > struct push_back;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/push_back.hpp" 2
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<>
+struct push_back_impl< aux::vector_tag >
+{
+    template< typename Vector, typename T > struct apply
+    {
+        typedef v_item<T,Vector,0> type;
+    };
+};
+
+}}
+# 22 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_back.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_back.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/pop_back_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/pop_back_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct pop_back_impl;
+template< typename Sequence > struct pop_back;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/pop_back.hpp" 2
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<>
+struct pop_back_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_mask<Vector,0> type;
+    };
+};
+
+}}
+# 23 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/back_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/back_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct back_impl;
+template< typename Sequence > struct back;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<>
+struct back_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : v_at<
+              Vector
+            , prior<typename Vector::size>::type::value
+            >
+    {
+    };
+};
+# 57 "/usr/include/boost-1_42/boost/mpl/vector/aux_/back.hpp"
+}}
+# 24 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/clear_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/clear_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct clear_impl;
+template< typename Sequence > struct clear;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/iterator_tags.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/iterator_tags.hpp"
+namespace boost { namespace mpl {
+
+struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; };
+struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; };
+struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; };
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/plus.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/plus.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/largest_int.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/largest_int.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T > struct integral_rank;
+
+template<> struct integral_rank<bool> : int_<1> {};
+template<> struct integral_rank<signed char> : int_<2> {};
+template<> struct integral_rank<char> : int_<3> {};
+template<> struct integral_rank<unsigned char> : int_<4> {};
+
+template<> struct integral_rank<wchar_t> : int_<5> {};
+
+template<> struct integral_rank<short> : int_<6> {};
+template<> struct integral_rank<unsigned short> : int_<7> {};
+template<> struct integral_rank<int> : int_<8> {};
+template<> struct integral_rank<unsigned int> : int_<9> {};
+template<> struct integral_rank<long> : int_<10> {};
+template<> struct integral_rank<unsigned long> : int_<11> {};
+
+
+template<> struct integral_rank<long_long_type> : int_<12> {};
+template<> struct integral_rank<ulong_long_type>: int_<13> {};
+
+
+template< typename T1, typename T2 > struct largest_int
+
+    : if_c<
+          ( integral_rank<T1>::value >= integral_rank<T2>::value )
+        , T1
+        , T2
+        >
+{
+
+
+
+
+
+
+};
+
+}}}
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/numeric_cast.hpp" 1
+# 30 "/usr/include/boost-1_42/boost/mpl/numeric_cast.hpp"
+namespace boost { namespace mpl {
+
+
+
+template< typename SourceTag, typename TargetTag > struct numeric_cast
+{
+    template< typename N > struct apply;
+};
+
+}}
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/arrays.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp" 2
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+
+typedef char (&no_tag)[1];
+typedef char (&yes_tag)[2];
+
+template< bool C_ > struct yes_no_tag
+{
+    typedef no_tag type;
+};
+
+template<> struct yes_no_tag<true>
+{
+    typedef yes_tag type;
+};
+
+
+template< long n > struct weighted_tag
+{
+
+    typedef char (&type)[n];
+
+
+
+
+};
+# 56 "/usr/include/boost-1_42/boost/mpl/aux_/yes_no.hpp"
+}}}
+# 21 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/has_xxx.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/msvc_typename.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/has_xxx.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/has_apply.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_apply.hpp" 2
+
+namespace boost { namespace mpl { namespace aux {
+
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+
+
+
+
+
+
+
+}}}
+# 24 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_never_true.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/use_preprocessed.hpp" 1
+# 29 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/compiler.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/stringize.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename F
+
+    , typename has_apply_ = typename aux::has_apply<F>::type
+
+    >
+struct apply_wrap0
+
+    : F::template apply< >
+{
+};
+
+template< typename F >
+struct apply_wrap0< F,true_ >
+    : F::apply
+{
+};
+
+template<
+      typename F, typename T1
+
+    >
+struct apply_wrap1
+
+    : F::template apply<T1>
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+
+    >
+struct apply_wrap2
+
+    : F::template apply< T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+
+    >
+struct apply_wrap3
+
+    : F::template apply< T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+
+    >
+struct apply_wrap4
+
+    : F::template apply< T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+
+    >
+struct apply_wrap5
+
+    : F::template apply< T1,T2,T3,T4,T5 >
+{
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 35 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/tag.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/tag.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/eval_if.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/eval_if.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename C = na
+    , typename F1 = na
+    , typename F2 = na
+    >
+struct eval_if
+
+
+
+
+{
+    typedef typename if_<C,F1,F2>::type f_;
+    typedef typename f_::type type;
+
+
+
+
+   
+};
+
+
+
+template<
+      bool C
+    , typename F1
+    , typename F2
+    >
+struct eval_if_c
+
+
+
+
+{
+    typedef typename if_c<C,F1,F2>::type f_;
+    typedef typename f_::type type;
+
+
+
+
+};
+
+template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< eval_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< eval_if< na , na , na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/tag.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_tag.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_tag.hpp"
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+# 20 "/usr/include/boost-1_42/boost/mpl/tag.hpp" 2
+
+
+namespace boost { namespace mpl {
+
+namespace aux {
+template< typename T > struct tag_impl
+{
+    typedef typename T::tag type;
+};
+}
+
+template< typename T, typename Default = void_ > struct tag
+
+    : if_<
+          aux::has_tag<T>
+        , aux::tag_impl<T>
+        , Default
+        >::type
+{
+# 48 "/usr/include/boost-1_42/boost/mpl/tag.hpp"
+};
+
+}}
+# 25 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/forwarding.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp" 2
+
+namespace boost { namespace mpl { namespace aux {
+
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    >
+struct cast1st_impl
+{
+    template< typename N1, typename N2 > struct apply
+
+        : apply_wrap2<
+              F
+            , typename apply_wrap1< numeric_cast<Tag1,Tag2>,N1 >::type
+            , N2
+            >
+    {
+# 46 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp"
+    };
+};
+
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    >
+struct cast2nd_impl
+{
+    template< typename N1, typename N2 > struct apply
+
+        : apply_wrap2<
+              F
+            , N1
+            , typename apply_wrap1< numeric_cast<Tag2,Tag1>,N2 >::type
+            >
+    {
+# 72 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_cast_utils.hpp"
+    };
+};
+
+}}}
+# 26 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/aux_/is_msvc_eti_arg.hpp"
+namespace boost { namespace mpl { namespace aux {
+# 62 "/usr/include/boost-1_42/boost/mpl/aux_/is_msvc_eti_arg.hpp"
+}}}
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp" 2
+
+
+
+
+namespace boost { namespace mpl { namespace aux {
+# 55 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_eti_base.hpp"
+template< typename T > struct msvc_eti_base
+    : T
+{
+
+    msvc_eti_base();
+
+    typedef T type;
+};
+
+
+
+template<> struct msvc_eti_base<int>
+{
+    typedef msvc_eti_base type;
+    typedef msvc_eti_base first;
+    typedef msvc_eti_base second;
+    typedef msvc_eti_base tag;
+    enum { value = 0 };
+};
+
+}}}
+# 30 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/plus.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/plus.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct plus_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< plus_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< plus_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct plus_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct plus_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct plus_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct plus_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct plus
+    : plus< plus< plus< plus< N1,N2 >, N3>, N4>, N5>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct plus< N1,N2,N3,N4,na >
+
+    : plus< plus< plus< N1,N2 >, N3>, N4>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3
+    >
+struct plus< N1,N2,N3,na,na >
+
+    : plus< plus< N1,N2 >, N3>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2
+    >
+struct plus< N1,N2,na,na,na >
+    : plus_impl<
+          typename plus_tag<N1>::type
+        , typename plus_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+
+
+
+
+};
+
+template<> struct plus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : plus< T1 , T2 > { }; }; template< typename Tag > struct lambda< plus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef plus< na , na > result_; typedef plus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< plus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< plus< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+template<>
+struct plus_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  + N2::value
+                )
+            >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 35 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/plus.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/minus.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/minus.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/minus.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/minus.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct minus_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< minus_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< minus_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct minus_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct minus_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct minus_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct minus_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct minus
+    : minus< minus< minus< minus< N1,N2 >, N3>, N4>, N5>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct minus< N1,N2,N3,N4,na >
+
+    : minus< minus< minus< N1,N2 >, N3>, N4>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3
+    >
+struct minus< N1,N2,N3,na,na >
+
+    : minus< minus< N1,N2 >, N3>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2
+    >
+struct minus< N1,N2,na,na,na >
+    : minus_impl<
+          typename minus_tag<N1>::type
+        , typename minus_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+
+
+
+
+};
+
+template<> struct minus< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : minus< T1 , T2 > { }; }; template< typename Tag > struct lambda< minus< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef minus< na , na > result_; typedef minus< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< minus< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< minus< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+template<>
+struct minus_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  - N2::value
+                )
+            >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 35 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/minus.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/advance_fwd.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/advance_fwd.hpp"
+namespace boost { namespace mpl {
+
+
+
+template< typename Tag > struct advance_impl;
+template< typename Iterator, typename N > struct advance;
+
+}}
+# 22 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/distance_fwd.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/distance_fwd.hpp"
+namespace boost { namespace mpl {
+
+
+
+template< typename Tag > struct distance_impl;
+template< typename First, typename Last > struct distance;
+
+}}
+# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/next.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/prior.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp" 2
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Vector
+    , long n_
+    >
+struct v_iter
+{
+    typedef aux::v_iter_tag tag;
+    typedef random_access_iterator_tag category;
+    typedef typename v_at<Vector,n_>::type type;
+
+    typedef Vector vector_;
+    typedef mpl::long_<n_> pos;
+# 56 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp"
+};
+
+
+
+
+template<
+      typename Vector
+    , long n_
+    >
+struct next< v_iter<Vector,n_> >
+{
+    typedef v_iter<Vector,(n_ + 1)> type;
+};
+
+template<
+      typename Vector
+    , long n_
+    >
+struct prior< v_iter<Vector,n_> >
+{
+    typedef v_iter<Vector,(n_ - 1)> type;
+};
+
+template<
+      typename Vector
+    , long n_
+    , typename Distance
+    >
+struct advance< v_iter<Vector,n_>,Distance>
+{
+    typedef v_iter<
+          Vector
+        , (n_ + Distance::value)
+        > type;
+};
+
+template<
+      typename Vector
+    , long n_
+    , long m_
+    >
+struct distance< v_iter<Vector,n_>, v_iter<Vector,m_> >
+    : mpl::long_<(m_ - n_)>
+{
+};
+# 128 "/usr/include/boost-1_42/boost/mpl/vector/aux_/iterator.hpp"
+}}
+# 23 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+template< typename Dummy = na > struct vector0;
+
+template<> struct vector0<na>
+{
+
+    typedef aux::vector_tag tag;
+    typedef vector0 type;
+    typedef long_<32768> lower_bound_;
+    typedef lower_bound_ upper_bound_;
+    typedef long_<0> size;
+
+    static aux::type_wrapper<void_> item_(...);
+# 48 "/usr/include/boost-1_42/boost/mpl/vector/aux_/vector0.hpp"
+};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<>
+struct clear_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef vector0<> type;
+    };
+};
+# 53 "/usr/include/boost-1_42/boost/mpl/vector/aux_/clear.hpp"
+}}
+# 25 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/O1_size_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/O1_size_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct O1_size_impl;
+template< typename Sequence > struct O1_size;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<>
+struct O1_size_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : Vector::size
+    {
+    };
+};
+# 54 "/usr/include/boost-1_42/boost/mpl/vector/aux_/O1_size.hpp"
+}}
+# 26 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/size_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/size_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct size_impl;
+template< typename Sequence > struct size;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp" 2
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<>
+struct size_impl< aux::vector_tag >
+    : O1_size_impl< aux::vector_tag >
+{
+};
+# 47 "/usr/include/boost-1_42/boost/mpl/vector/aux_/size.hpp"
+}}
+# 27 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/empty_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/empty_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct empty_impl;
+template< typename Sequence > struct empty;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<>
+struct empty_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+        : is_same<
+              typename Vector::lower_bound_
+            , typename Vector::upper_bound_
+            >
+    {
+    };
+};
+# 66 "/usr/include/boost-1_42/boost/mpl/vector/aux_/empty.hpp"
+}}
+# 28 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/begin_end.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/vector/aux_/begin_end.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/begin_end_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/begin_end_fwd.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct begin_impl;
+template< typename Tag > struct end_impl;
+
+template< typename Sequence > struct begin;
+template< typename Sequence > struct end;
+
+}}
+# 22 "/usr/include/boost-1_42/boost/mpl/vector/aux_/begin_end.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+template<>
+struct begin_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_iter<Vector,0> type;
+    };
+};
+
+template<>
+struct end_impl< aux::vector_tag >
+{
+    template< typename Vector > struct apply
+    {
+        typedef v_iter<Vector,Vector::size::value> type;
+    };
+};
+
+}}
+# 32 "/usr/include/boost-1_42/boost/mpl/vector/vector0.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
+# 49 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename T0
+    >
+struct vector1
+    : v_item<
+          T0
+        , vector0< >
+        >
+{
+    typedef vector1 type;
+};
+
+template<
+      typename T0, typename T1
+    >
+struct vector2
+    : v_item<
+          T1
+        , vector1<T0>
+        >
+{
+    typedef vector2 type;
+};
+
+template<
+      typename T0, typename T1, typename T2
+    >
+struct vector3
+    : v_item<
+          T2
+        , vector2< T0,T1 >
+        >
+{
+    typedef vector3 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3
+    >
+struct vector4
+    : v_item<
+          T3
+        , vector3< T0,T1,T2 >
+        >
+{
+    typedef vector4 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    >
+struct vector5
+    : v_item<
+          T4
+        , vector4< T0,T1,T2,T3 >
+        >
+{
+    typedef vector5 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct vector6
+    : v_item<
+          T5
+        , vector5< T0,T1,T2,T3,T4 >
+        >
+{
+    typedef vector6 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6
+    >
+struct vector7
+    : v_item<
+          T6
+        , vector6< T0,T1,T2,T3,T4,T5 >
+        >
+{
+    typedef vector7 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7
+    >
+struct vector8
+    : v_item<
+          T7
+        , vector7< T0,T1,T2,T3,T4,T5,T6 >
+        >
+{
+    typedef vector8 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8
+    >
+struct vector9
+    : v_item<
+          T8
+        , vector8< T0,T1,T2,T3,T4,T5,T6,T7 >
+        >
+{
+    typedef vector9 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    >
+struct vector10
+    : v_item<
+          T9
+        , vector9< T0,T1,T2,T3,T4,T5,T6,T7,T8 >
+        >
+{
+    typedef vector10 type;
+};
+
+}}
+# 50 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/mpl/vector/vector10.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 1
+# 49 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10
+    >
+struct vector11
+    : v_item<
+          T10
+        , vector10< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9 >
+        >
+{
+    typedef vector11 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11
+    >
+struct vector12
+    : v_item<
+          T11
+        , vector11< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10 >
+        >
+{
+    typedef vector12 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12
+    >
+struct vector13
+    : v_item<
+          T12
+        , vector12< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11 >
+        >
+{
+    typedef vector13 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13
+    >
+struct vector14
+    : v_item<
+          T13
+        , vector13< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12 >
+        >
+{
+    typedef vector14 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    >
+struct vector15
+    : v_item<
+          T14
+        , vector14< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13 >
+        >
+{
+    typedef vector15 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15
+    >
+struct vector16
+    : v_item<
+          T15
+        , vector15< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14 >
+        >
+{
+    typedef vector16 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16
+    >
+struct vector17
+    : v_item<
+          T16
+        , vector16< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15 >
+        >
+{
+    typedef vector17 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17
+    >
+struct vector18
+    : v_item<
+          T17
+        , vector17< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16 >
+        >
+{
+    typedef vector18 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18
+    >
+struct vector19
+    : v_item<
+          T18
+        , vector18< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17 >
+        >
+{
+    typedef vector19 type;
+};
+
+template<
+      typename T0, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename T6, typename T7, typename T8, typename T9
+    , typename T10, typename T11, typename T12, typename T13, typename T14
+    , typename T15, typename T16, typename T17, typename T18, typename T19
+    >
+struct vector20
+    : v_item<
+          T19
+        , vector19< T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18 >
+        >
+{
+    typedef vector20 type;
+};
+
+}}
+# 50 "/usr/include/boost-1_42/boost/mpl/vector/aux_/include_preprocessed.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/mpl/vector/vector20.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/enum_params_with_a_default.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/enum_params_with_a_default.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/facilities/intercept.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_binary_params.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_params_with_a_default.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/preprocessor/enum_params_with_a_default.hpp" 2
+# 13 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iterate.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/iterate.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/array/data.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/array/size.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/array/elem.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/slot.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/slot/slot.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/def.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/slot/slot.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/preprocessor/iteration/iterate.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/preprocessor/iterate.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+template < class T0 = mpl::void_ , class T1 = mpl::void_ , class T2 = mpl::void_ , class T3 = mpl::void_ , class T4 = mpl::void_ , class T5 = mpl::void_ , class T6 = mpl::void_ , class T7 = mpl::void_ , class T8 = mpl::void_ , class T9 = mpl::void_ , class T10 = mpl::void_ , class T11 = mpl::void_ , class T12 = mpl::void_ , class T13 = mpl::void_ , class T14 = mpl::void_ , class T15 = mpl::void_ , class T16 = mpl::void_ >
+struct type_list
+    : mpl::vector17< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16>
+{
+};
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+   
+    >
+struct type_list<
+   
+   
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector0<>
+{
+};
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0
+    >
+struct type_list<
+    T0
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector1< T0>
+{
+};
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1
+    >
+struct type_list<
+    T0 , T1
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector2< T0 , T1>
+{
+};
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2
+    >
+struct type_list<
+    T0 , T1 , T2
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector3< T0 , T1 , T2>
+{
+};
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3
+    >
+struct type_list<
+    T0 , T1 , T2 , T3
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector4< T0 , T1 , T2 , T3>
+{
+};
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector5< T0 , T1 , T2 , T3 , T4>
+{
+};
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector6< T0 , T1 , T2 , T3 , T4 , T5>
+{
+};
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector7< T0 , T1 , T2 , T3 , T4 , T5 , T6>
+{
+};
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector8< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+{
+};
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector9< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+{
+};
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector10< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+{
+};
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector11< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
+{
+};
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector12< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
+{
+};
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector13< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
+{
+};
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+    ,
+   
+ mpl::void_ , mpl::void_ , mpl::void_
+    >
+   : mpl::vector14< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
+{
+};
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+    ,
+   
+ mpl::void_ , mpl::void_
+    >
+   : mpl::vector15< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
+{
+};
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 1
+# 41 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp"
+template <
+    class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14 , class T15
+    >
+struct type_list<
+    T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15
+    ,
+   
+ mpl::void_
+    >
+   : mpl::vector16< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15>
+{
+};
+# 128 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/python/detail/type_list_impl.hpp" 2
+
+
+}}}
+# 35 "/usr/include/boost-1_42/boost/python/detail/type_list.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp" 2
+
+namespace boost {
+
+
+
+template< typename T > struct remove_reference { typedef T type; };
+template< typename T > struct remove_reference<T&> { typedef T type; };
+# 46 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 49 "/usr/include/boost-1_42/boost/type_traits/remove_reference.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/local.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/mpl_lambda.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object_core.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/call.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/ptr.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/python/ptr.hpp"
+namespace boost { namespace python {
+
+template<class Ptr> class pointer_wrapper
+{
+ public:
+    typedef Ptr type;
+
+    explicit pointer_wrapper(Ptr x): p_(x) {}
+    operator Ptr() const { return p_; }
+    Ptr get() const { return p_; }
+ private:
+    Ptr p_;
+};
+
+template<class T>
+inline pointer_wrapper<T> ptr(T t)
+{
+    return pointer_wrapper<T>(t);
+}
+
+
+template<typename T>
+class is_pointer_wrapper
+    : public mpl::false_
+{
+};
+
+template<typename T>
+class is_pointer_wrapper<pointer_wrapper<T> >
+    : public mpl::true_
+{
+};
+
+template<typename T>
+class unwrap_pointer
+{
+ public:
+    typedef T type;
+};
+
+template<typename T>
+class unwrap_pointer<pointer_wrapper<T> >
+{
+ public:
+    typedef T type;
+};
+# 126 "/usr/include/boost-1_42/boost/python/ptr.hpp"
+}}
+# 9 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/instance_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/utility.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/utility.hpp"
+# 1 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat_from_to.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat_from_to.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/repetition/repeat_from_to.hpp" 2
+# 17 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp" 2
+# 53 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp"
+namespace boost
+{
+# 65 "/usr/include/boost-1_42/boost/utility/base_from_member.hpp"
+template < typename MemberType, int UniqueID = 0 >
+class base_from_member
+{
+protected:
+    MemberType member;
+
+    base_from_member()
+        : member()
+        {}
+
+   
+ template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {} template < typename T0 , typename T1 > explicit base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {} template < typename T0 , typename T1 , typename T2 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 ) : member( x0 , x1 , x2 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 ) : member( x0 , x1 , x2 , x3 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 ) : member( x0 , x1 , x2 , x3 , x4 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 ) : member( x0 , x1 , x2 , x3 , x4 , x5 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > explicit base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 , T9 x9 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 ) {}
+
+};
+
+}
+# 14 "/usr/include/boost-1_42/boost/utility.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/utility/binary.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/utility/binary.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/control/deduce_d.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/control/deduce_d.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/control/deduce_d.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/cat.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/preprocessor/seq/cat.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/seq.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/preprocessor/seq/seq.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/elem.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/seq/seq.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/size.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/preprocessor/seq/fold_left.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/preprocessor/seq/cat.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/seq/transform.hpp" 1
+# 31 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/mod.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/mod.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/detail/div_base.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/detail/div_base.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/comparison/less_equal.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/comparison/less_equal.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/logical/not.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/comparison/less_equal.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/detail/div_base.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/preprocessor/arithmetic/mod.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/utility/binary.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/utility.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/checked_delete.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/checked_delete.hpp"
+namespace boost
+{
+
+
+
+template<class T> inline void checked_delete(T * x)
+{
+
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+
+template<class T> inline void checked_array_delete(T * x)
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete [] x;
+}
+
+template<class T> struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+
+        boost::checked_delete(x);
+    }
+};
+
+template<class T> struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        boost::checked_array_delete(x);
+    }
+};
+
+}
+# 17 "/usr/include/boost-1_42/boost/utility.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/next_prior.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/next_prior.hpp"
+namespace boost {
+# 29 "/usr/include/boost-1_42/boost/next_prior.hpp"
+template <class T>
+inline T next(T x) { return ++x; }
+
+template <class T, class Distance>
+inline T next(T x, Distance n)
+{
+    std::advance(x, n);
+    return x;
+}
+
+template <class T>
+inline T prior(T x) { return --x; }
+
+template <class T, class Distance>
+inline T prior(T x, Distance n)
+{
+    std::advance(x, -n);
+    return x;
+}
+
+}
+# 18 "/usr/include/boost-1_42/boost/utility.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/noncopyable.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/noncopyable.hpp"
+namespace boost {
+
+
+
+
+
+
+namespace noncopyable_
+{
+  class noncopyable
+  {
+   protected:
+      noncopyable() {}
+      ~noncopyable() {}
+   private:
+      noncopyable( const noncopyable& );
+      const noncopyable& operator=( const noncopyable& );
+  };
+}
+
+typedef noncopyable_::noncopyable noncopyable;
+
+}
+# 19 "/usr/include/boost-1_42/boost/utility.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/type_id.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/type_id.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/msvc_typeinfo.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/operators.hpp" 1
+# 84 "/usr/include/boost-1_42/boost/operators.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/iterator.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 19 "/usr/include/boost-1_42/boost/iterator.hpp" 2
+
+
+namespace boost
+{
+# 39 "/usr/include/boost-1_42/boost/iterator.hpp"
+  namespace detail {
+   template <class Category, class T, class Distance, class Pointer, class Reference>
+
+   struct iterator_base : std::iterator<Category, T, Distance, Pointer, Reference> {};
+# 51 "/usr/include/boost-1_42/boost/iterator.hpp"
+  }
+
+  template <class Category, class T, class Distance = std::ptrdiff_t,
+            class Pointer = T*, class Reference = T&>
+  struct iterator : boost::detail::iterator_base<Category, T, Distance, Pointer, Reference> {};
+
+}
+# 85 "/usr/include/boost-1_42/boost/operators.hpp" 2
+# 95 "/usr/include/boost-1_42/boost/operators.hpp"
+namespace boost {
+namespace detail {
+
+template <typename T> class empty_base {
+
+
+
+
+
+
+};
+
+}
+}
+# 118 "/usr/include/boost-1_42/boost/operators.hpp"
+namespace boost
+{
+
+
+
+
+
+
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct less_than_comparable2 : B
+{
+     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
+     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
+     friend bool operator>(const U& x, const T& y) { return y < x; }
+     friend bool operator<(const U& x, const T& y) { return y > x; }
+     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct less_than_comparable1 : B
+{
+     friend bool operator>(const T& x, const T& y) { return y < x; }
+     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct equality_comparable2 : B
+{
+     friend bool operator==(const U& y, const T& x) { return x == y; }
+     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
+     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct equality_comparable1 : B
+{
+     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
+};
+# 254 "/usr/include/boost-1_42/boost/operators.hpp"
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } friend T operator *( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv *= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } friend T operator +( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv += lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class U, class B = ::boost::detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } friend T operator ^( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv ^= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } friend T operator &( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv &= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } friend T operator |( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv |= lhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } };
+
+
+
+
+
+
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct incrementable : B
+{
+  friend T operator++(T& x, int)
+  {
+    incrementable_type nrv(x);
+    ++x;
+    return nrv;
+  }
+private:
+  typedef T incrementable_type;
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct decrementable : B
+{
+  friend T operator--(T& x, int)
+  {
+    decrementable_type nrv(x);
+    --x;
+    return nrv;
+  }
+private:
+  typedef T decrementable_type;
+};
+
+
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct dereferenceable : B
+{
+  P operator->() const
+  {
+    return &*static_cast<const T&>(*this);
+  }
+};
+
+template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
+struct indexable : B
+{
+  R operator[](I n) const
+  {
+    return *(static_cast<const T&>(*this) + n);
+  }
+};
+# 352 "/usr/include/boost-1_42/boost/operators.hpp"
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } };
+template <class T, class U, class B = ::boost::detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } }; template <class T, class B = ::boost::detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } };
+
+
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct equivalent2 : B
+{
+  friend bool operator==(const T& x, const U& y)
+  {
+    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
+  }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct equivalent1 : B
+{
+  friend bool operator==(const T&x, const T&y)
+  {
+    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
+  }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct partially_ordered2 : B
+{
+  friend bool operator<=(const T& x, const U& y)
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+  friend bool operator>=(const T& x, const U& y)
+    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
+  friend bool operator>(const U& x, const T& y)
+    { return y < x; }
+  friend bool operator<(const U& x, const T& y)
+    { return y > x; }
+  friend bool operator<=(const U& x, const T& y)
+    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
+  friend bool operator>=(const U& x, const T& y)
+    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct partially_ordered1 : B
+{
+  friend bool operator>(const T& x, const T& y)
+    { return y < x; }
+  friend bool operator<=(const T& x, const T& y)
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+  friend bool operator>=(const T& x, const T& y)
+    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
+};
+
+
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct totally_ordered2
+    : less_than_comparable2<T, U
+    , equality_comparable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct totally_ordered1
+    : less_than_comparable1<T
+    , equality_comparable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct additive2
+    : addable2<T, U
+    , subtractable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct additive1
+    : addable1<T
+    , subtractable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct multiplicative2
+    : multipliable2<T, U
+    , dividable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct multiplicative1
+    : multipliable1<T
+    , dividable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct integer_multiplicative2
+    : multiplicative2<T, U
+    , modable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct integer_multiplicative1
+    : multiplicative1<T
+    , modable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct arithmetic2
+    : additive2<T, U
+    , multiplicative2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct arithmetic1
+    : additive1<T
+    , multiplicative1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct integer_arithmetic2
+    : additive2<T, U
+    , integer_multiplicative2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct integer_arithmetic1
+    : additive1<T
+    , integer_multiplicative1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct bitwise2
+    : xorable2<T, U
+    , andable2<T, U
+    , orable2<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct bitwise1
+    : xorable1<T
+    , andable1<T
+    , orable1<T, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct unit_steppable
+    : incrementable<T
+    , decrementable<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct shiftable2
+    : left_shiftable2<T, U
+    , right_shiftable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct shiftable1
+    : left_shiftable1<T
+    , right_shiftable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ring_operators2
+    : additive2<T, U
+    , subtractable2_left<T, U
+    , multipliable2<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ring_operators1
+    : additive1<T
+    , multipliable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_ring_operators2
+    : ring_operators2<T, U
+    , totally_ordered2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_ring_operators1
+    : ring_operators1<T
+    , totally_ordered1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct field_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct field_operators1
+    : ring_operators1<T
+    , dividable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_field_operators2
+    : field_operators2<T, U
+    , totally_ordered2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_field_operators1
+    : field_operators1<T
+    , totally_ordered1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct euclidian_ring_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U
+    , modable2<T, U
+    , modable2_left<T, U, B
+      > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct euclidian_ring_operators1
+    : ring_operators1<T
+    , dividable1<T
+    , modable1<T, B
+      > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidian_ring_operators2
+    : totally_ordered2<T, U
+    , euclidian_ring_operators2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidian_ring_operators1
+    : totally_ordered1<T
+    , euclidian_ring_operators1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U
+    , modable2<T, U
+    , modable2_left<T, U, B
+      > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators1
+    : ring_operators1<T
+    , dividable1<T
+    , modable1<T, B
+      > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators2
+    : totally_ordered2<T, U
+    , euclidean_ring_operators2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators1
+    : totally_ordered1<T
+    , euclidean_ring_operators1<T, B
+      > > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct input_iteratable
+    : equality_comparable1<T
+    , incrementable<T
+    , dereferenceable<T, P, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct output_iteratable
+    : incrementable<T, B
+      > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct forward_iteratable
+    : input_iteratable<T, P, B
+      > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct bidirectional_iteratable
+    : forward_iteratable<T, P
+    , decrementable<T, B
+      > > {};
+
+
+
+
+
+template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
+struct random_access_iteratable
+    : bidirectional_iteratable<T, P
+    , less_than_comparable1<T
+    , additive2<T, D
+    , indexable<T, D, R, B
+      > > > > {};
+
+
+}
+# 718 "/usr/include/boost-1_42/boost/operators.hpp"
+namespace boost {
+
+
+namespace detail {
+  struct true_t {};
+  struct false_t {};
+}
+
+
+
+
+template<class T> struct is_chained_base {
+  typedef ::boost::detail::false_t value;
+};
+
+}
+# 829 "/usr/include/boost-1_42/boost/operators.hpp"
+namespace boost {
+
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {}; template<class T, class U, class B> struct less_than_comparable<T, U, B, ::boost::detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, ::boost::detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::less_than_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::less_than_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::less_than_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {}; template<class T, class U, class B> struct equality_comparable<T, U, B, ::boost::detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, ::boost::detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equality_comparable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equality_comparable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equality_comparable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable : multipliable2<T, U, B> {}; template<class T, class U, class B> struct multipliable<T, U, B, ::boost::detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, ::boost::detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multipliable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multipliable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multipliable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct addable : addable2<T, U, B> {}; template<class T, class U, class B> struct addable<T, U, B, ::boost::detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, ::boost::detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::addable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::addable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::addable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct subtractable : subtractable2<T, U, B> {}; template<class T, class U, class B> struct subtractable<T, U, B, ::boost::detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, ::boost::detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::subtractable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::subtractable1<T, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class B> struct is_chained_base< ::boost::subtractable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct dividable : dividable2<T, U, B> {}; template<class T, class U, class B> struct dividable<T, U, B, ::boost::detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, ::boost::detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::dividable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::dividable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::dividable1<T, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class B> struct is_chained_base< ::boost::dividable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct modable : modable2<T, U, B> {}; template<class T, class U, class B> struct modable<T, U, B, ::boost::detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, ::boost::detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::modable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::modable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::modable1<T, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class B> struct is_chained_base< ::boost::modable2_left<T, U, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct xorable : xorable2<T, U, B> {}; template<class T, class U, class B> struct xorable<T, U, B, ::boost::detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, ::boost::detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::xorable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::xorable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::xorable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct andable : andable2<T, U, B> {}; template<class T, class U, class B> struct andable<T, U, B, ::boost::detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, ::boost::detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::andable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::andable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::andable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct orable : orable2<T, U, B> {}; template<class T, class U, class B> struct orable<T, U, B, ::boost::detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, ::boost::detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::orable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::orable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::orable1<T, B> > { typedef ::boost::detail::true_t value; };
+
+ template<class T, class B> struct is_chained_base< ::boost::incrementable<T, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class B> struct is_chained_base< ::boost::decrementable<T, B> > { typedef ::boost::detail::true_t value; };
+
+ template<class T, class U, class B> struct is_chained_base< ::boost::dereferenceable<T, U, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class V, class B> struct is_chained_base< ::boost::indexable<T, U, V, B> > { typedef ::boost::detail::true_t value; };
+
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct left_shiftable : left_shiftable2<T, U, B> {}; template<class T, class U, class B> struct left_shiftable<T, U, B, ::boost::detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, ::boost::detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::left_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::left_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::left_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct right_shiftable : right_shiftable2<T, U, B> {}; template<class T, class U, class B> struct right_shiftable<T, U, B, ::boost::detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, ::boost::detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::right_shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::right_shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::right_shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equivalent : equivalent2<T, U, B> {}; template<class T, class U, class B> struct equivalent<T, U, B, ::boost::detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, ::boost::detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::equivalent<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::equivalent2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::equivalent1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct partially_ordered : partially_ordered2<T, U, B> {}; template<class T, class U, class B> struct partially_ordered<T, U, B, ::boost::detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, ::boost::detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::partially_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::partially_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::partially_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
+
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct totally_ordered : totally_ordered2<T, U, B> {}; template<class T, class U, class B> struct totally_ordered<T, U, B, ::boost::detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, ::boost::detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::totally_ordered<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::totally_ordered2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::totally_ordered1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct additive : additive2<T, U, B> {}; template<class T, class U, class B> struct additive<T, U, B, ::boost::detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, ::boost::detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::additive<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::additive2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::additive1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multiplicative : multiplicative2<T, U, B> {}; template<class T, class U, class B> struct multiplicative<T, U, B, ::boost::detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, ::boost::detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_multiplicative : integer_multiplicative2<T, U, B> {}; template<class T, class U, class B> struct integer_multiplicative<T, U, B, ::boost::detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, ::boost::detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_multiplicative<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_multiplicative2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_multiplicative1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct arithmetic : arithmetic2<T, U, B> {}; template<class T, class U, class B> struct arithmetic<T, U, B, ::boost::detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, ::boost::detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_arithmetic : integer_arithmetic2<T, U, B> {}; template<class T, class U, class B> struct integer_arithmetic<T, U, B, ::boost::detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, ::boost::detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::integer_arithmetic<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::integer_arithmetic2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::integer_arithmetic1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise : bitwise2<T, U, B> {}; template<class T, class U, class B> struct bitwise<T, U, B, ::boost::detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, ::boost::detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::bitwise<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::bitwise2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::bitwise1<T, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class B> struct is_chained_base< ::boost::unit_steppable<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable : shiftable2<T, U, B> {}; template<class T, class U, class B> struct shiftable<T, U, B, ::boost::detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, ::boost::detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::shiftable<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::shiftable2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::shiftable1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ring_operators : ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ring_operators<T, U, B, ::boost::detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, ::boost::detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_ring_operators : ordered_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct field_operators : field_operators2<T, U, B> {}; template<class T, class U, class B> struct field_operators<T, U, B, ::boost::detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, ::boost::detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_field_operators : ordered_field_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_field_operators<T, U, B, ::boost::detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, ::boost::detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_field_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_field_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_field_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidian_ring_operators : euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidian_ring_operators : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidian_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidian_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidean_ring_operators : euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidean_ring_operators : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, ::boost::detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, ::boost::detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ::boost::ordered_euclidean_ring_operators<T, U, B, O> > { typedef ::boost::detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators2<T, U, B> > { typedef ::boost::detail::true_t value; }; template<class T, class B> struct is_chained_base< ::boost::ordered_euclidean_ring_operators1<T, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class B> struct is_chained_base< ::boost::input_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class B> struct is_chained_base< ::boost::output_iteratable<T, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class B> struct is_chained_base< ::boost::forward_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class B> struct is_chained_base< ::boost::bidirectional_iteratable<T, U, B> > { typedef ::boost::detail::true_t value; };
+ template<class T, class U, class V, class W, class B> struct is_chained_base< ::boost::random_access_iteratable<T, U, V, W, B> > { typedef ::boost::detail::true_t value; };
+# 891 "/usr/include/boost-1_42/boost/operators.hpp"
+template <class T, class U>
+struct operators2
+    : totally_ordered2<T,U
+    , integer_arithmetic2<T,U
+    , bitwise2<T,U
+      > > > {};
+
+
+template <class T, class U = T>
+struct operators : operators2<T, U> {};
+
+template <class T> struct operators<T, T>
+
+
+
+    : totally_ordered<T
+    , integer_arithmetic<T
+    , bitwise<T
+    , unit_steppable<T
+      > > > > {};
+
+
+
+
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V const *,
+          class R = V const &>
+struct input_iterator_helper
+  : input_iteratable<T, P
+  , boost::iterator<std::input_iterator_tag, V, D, P, R
+    > > {};
+
+template<class T>
+struct output_iterator_helper
+  : output_iteratable<T
+  , boost::iterator<std::output_iterator_tag, void, void, void, void
+  > >
+{
+  T& operator*() { return static_cast<T&>(*this); }
+  T& operator++() { return static_cast<T&>(*this); }
+};
+
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V*,
+          class R = V&>
+struct forward_iterator_helper
+  : forward_iteratable<T, P
+  , boost::iterator<std::forward_iterator_tag, V, D, P, R
+    > > {};
+
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V*,
+          class R = V&>
+struct bidirectional_iterator_helper
+  : bidirectional_iteratable<T, P
+  , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
+    > > {};
+
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V*,
+          class R = V&>
+struct random_access_iterator_helper
+  : random_access_iteratable<T, P, D, R
+  , boost::iterator<std::random_access_iterator_tag, V, D, P, R
+    > >
+{
+  friend D requires_difference_operator(const T& x, const T& y) {
+    return x - y;
+  }
+};
+
+}
+# 12 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 2 3
+# 14 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/static_assert.hpp" 1
+# 45 "/usr/include/boost-1_42/boost/static_assert.hpp"
+namespace boost{
+
+
+template <bool x> struct STATIC_ASSERTION_FAILURE;
+
+template <> struct STATIC_ASSERTION_FAILURE<true> { enum { value = 1 }; };
+
+
+template<int x> struct static_assert_test{};
+
+}
+# 16 "/usr/include/boost-1_42/boost/python/type_id.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/python/type_id.hpp"
+namespace boost { namespace python {
+# 44 "/usr/include/boost-1_42/boost/python/type_id.hpp"
+bool cxxabi_cxa_demangle_is_broken();
+
+
+
+
+
+
+struct type_info : private totally_ordered<type_info>
+{
+    inline type_info(std::type_info const& = typeid(void));
+
+    inline bool operator<(type_info const& rhs) const;
+    inline bool operator==(type_info const& rhs) const;
+
+    char const* name() const;
+    friend std::ostream& operator<<(
+        std::ostream&, type_info const&);
+
+ private:
+
+    typedef char const* base_id_t;
+
+
+
+
+    base_id_t m_base_type;
+};
+
+
+
+
+
+
+
+template <class T>
+inline type_info type_id()
+{
+    return type_info(
+
+
+
+        typeid(T)
+
+
+
+        );
+}
+# 119 "/usr/include/boost-1_42/boost/python/type_id.hpp"
+inline type_info::type_info(std::type_info const& id)
+    : m_base_type(
+
+        id.name()
+
+
+
+        )
+{
+}
+
+inline bool type_info::operator<(type_info const& rhs) const
+{
+
+    return std::strcmp(m_base_type, rhs.m_base_type) < 0;
+
+
+
+}
+
+inline bool type_info::operator==(type_info const& rhs) const
+{
+
+    return !std::strcmp(m_base_type, rhs.m_base_type);
+
+
+
+}
+
+
+namespace detail
+{
+  char const* gcc_demangle(char const*);
+}
+
+
+inline char const* type_info::name() const
+{
+    char const* raw_name
+        = m_base_type
+
+
+
+        ;
+
+
+    return detail::gcc_demangle(raw_name);
+
+
+
+}
+
+
+ std::ostream& operator<<(std::ostream&, type_info const&);
+
+
+template<>
+inline type_info type_id<void>()
+{
+    return type_info (typeid (void *));
+}
+
+template<>
+inline type_info type_id<const volatile void>()
+{
+    return type_info (typeid (void *));
+}
+
+
+
+
+}}
+# 12 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 13 "/usr/include/boost-1_42/boost/python/instance_holder.hpp" 2
+
+namespace boost { namespace python {
+
+
+struct instance_holder : private noncopyable
+{
+ public:
+    instance_holder();
+    virtual ~instance_holder();
+
+
+    instance_holder* next() const;
+
+
+
+
+
+
+
+    virtual void* holds(type_info, bool null_ptr_only) = 0;
+
+    void install(PyObject* inst) throw();
+
+
+
+
+
+
+    static void* allocate(PyObject*, std::size_t offset, std::size_t size);
+
+
+
+    static void deallocate(PyObject*, void* storage) throw();
+ private:
+    instance_holder* m_next;
+};
+
+
+
+
+
+
+
+inline instance_holder* instance_holder::next() const
+{
+    return m_next;
+}
+
+}}
+# 15 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/inheritance_query.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object/inheritance_query.hpp"
+namespace boost { namespace python { namespace objects {
+
+ void* find_static_type(void* p, type_info src, type_info dst);
+ void* find_dynamic_type(void* p, type_info src, type_info dst);
+
+}}}
+# 16 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/forward.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object/forward.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/value_arg.hpp" 1
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/copy_ctor_mutates_rhs.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/is_xxx.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/detail/is_xxx.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/detail/is_xxx.hpp" 2
+# 10 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp" 2
+
+
+
+namespace boost { namespace python { namespace detail {
+
+
+
+template <class T> struct is_auto_ptr : mpl::false_ { }; template < class T0 > struct is_auto_ptr< std::auto_ptr< T0 > > : mpl::true_ { };
+# 28 "/usr/include/boost-1_42/boost/python/detail/is_auto_ptr.hpp"
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/detail/copy_ctor_mutates_rhs.hpp" 2
+
+
+namespace boost { namespace python { namespace detail {
+
+template <class T>
+struct copy_ctor_mutates_rhs
+    : is_auto_ptr<T>
+{
+};
+
+}}}
+# 8 "/usr/include/boost-1_42/boost/python/detail/value_arg.hpp" 2
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+template <class T>
+struct value_arg
+  : mpl::if_<
+        copy_ctor_mutates_rhs<T>
+      , T
+      , typename add_reference<
+            typename add_const<T>::type
+        >::type
+  >
+{};
+
+}}}
+# 14 "/usr/include/boost-1_42/boost/python/object/forward.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/or.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/or.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/nested_type_wknd.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/mpl/aux_/nested_type_wknd.hpp"
+namespace boost { namespace mpl { namespace aux {
+template< typename T > struct nested_type_wknd
+    : T::type
+{
+};
+}}}
+# 24 "/usr/include/boost-1_42/boost/mpl/or.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/mpl/or.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/or.hpp"
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct or_impl
+    : true_
+{
+};
+
+template< typename T1, typename T2, typename T3, typename T4 >
+struct or_impl< false,T1,T2,T3,T4 >
+    : or_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4
+        , false_
+        >
+{
+};
+
+template<>
+struct or_impl<
+          false
+        , false_, false_, false_, false_
+        >
+    : false_
+{
+};
+
+}
+
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = false_, typename T4 = false_, typename T5 = false_
+    >
+struct or_
+
+    : aux::or_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4, T5
+        >
+
+{
+   
+
+
+
+
+};
+
+template<> struct or_<
+
+
+
+ na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 44 "/usr/include/boost-1_42/boost/mpl/or.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/python/object/forward.hpp" 2
+
+
+namespace boost { namespace python { namespace objects {
+
+
+
+
+template <class T>
+struct reference_to_value
+{
+    typedef typename add_reference<typename add_const<T>::type>::type reference;
+
+    reference_to_value(reference x) : m_value(x) {}
+    reference get() const { return m_value; }
+ private:
+    reference m_value;
+};
+
+
+
+
+template <class T>
+struct forward
+    : mpl::if_<
+# 54 "/usr/include/boost-1_42/boost/python/object/forward.hpp"
+          mpl::or_<python::detail::copy_ctor_mutates_rhs<T>, is_scalar<T> >
+
+        , T
+        , reference_to_value<T>
+      >
+{
+};
+
+
+template<typename T>
+struct unforward
+{
+    typedef typename unwrap_reference<T>::type& type;
+};
+
+template<typename T>
+struct unforward<reference_to_value<T> >
+{
+    typedef T type;
+};
+
+template <typename T>
+struct unforward_cref
+  : python::detail::value_arg<
+        typename unwrap_reference<T>::type
+    >
+{
+};
+
+template<typename T>
+struct unforward_cref<reference_to_value<T> >
+  : add_reference<typename add_const<T>::type>
+{
+};
+# 172 "/usr/include/boost-1_42/boost/python/object/forward.hpp"
+template <class T>
+typename reference_to_value<T>::reference
+do_unforward(reference_to_value<T> const& x, int)
+{
+    return x.get();
+}
+
+template <class T>
+typename reference_wrapper<T>::type&
+do_unforward(reference_wrapper<T> const& x, int)
+{
+    return x.get();
+}
+
+template <class T>
+T const& do_unforward(T const& x, ...)
+{
+    return x;
+}
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/pointee.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/pointee.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp" 2
+
+namespace boost {
+
+
+
+template< typename T > struct remove_pointer { typedef T type; };
+template< typename T > struct remove_pointer<T*> { typedef T type; };
+template< typename T > struct remove_pointer<T* const> { typedef T type; };
+template< typename T > struct remove_pointer<T* volatile> { typedef T type; };
+template< typename T > struct remove_pointer<T* const volatile> { typedef T type; };
+
+
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 42 "/usr/include/boost-1_42/boost/type_traits/remove_pointer.hpp" 2
+# 12 "/usr/include/boost-1_42/boost/python/pointee.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <bool is_ptr = true>
+  struct pointee_impl
+  {
+      template <class T> struct apply : remove_pointer<T> {};
+  };
+
+  template <>
+  struct pointee_impl<false>
+  {
+      template <class T> struct apply
+      {
+          typedef typename T::element_type type;
+      };
+  };
+}
+
+template <class T>
+struct pointee
+    : detail::pointee_impl<
+        ::boost::is_pointer<T>::value
+      >::template apply<T>
+{
+};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/wrapper_base.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp" 2
+
+
+namespace boost{
+# 106 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp"
+template< typename T > struct is_polymorphic : ::boost::integral_constant<bool,__is_polymorphic(T)> { };
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 113 "/usr/include/boost-1_42/boost/type_traits/is_polymorphic.hpp" 2
+# 9 "/usr/include/boost-1_42/boost/python/detail/wrapper_base.hpp" 2
+
+
+namespace boost { namespace python {
+
+class override;
+
+namespace detail
+{
+  class wrapper_base;
+
+  namespace wrapper_base_
+  {
+    inline PyObject* get_owner(wrapper_base const volatile& w);
+
+    inline PyObject*
+    owner_impl(void const volatile* , mpl::false_)
+    {
+        return 0;
+    }
+
+    template <class T>
+    inline PyObject*
+    owner_impl(T const volatile* x, mpl::true_);
+
+    template <class T>
+    inline PyObject*
+    owner(T const volatile* x)
+    {
+        return wrapper_base_::owner_impl(x,is_polymorphic<T>());
+    }
+  }
+
+  class wrapper_base
+  {
+      friend void initialize_wrapper(PyObject* self, wrapper_base* w);
+      friend PyObject* wrapper_base_::get_owner(wrapper_base const volatile& w);
+   protected:
+      wrapper_base() : m_self(0) {}
+
+      override get_override(
+          char const* name, PyTypeObject* class_object) const;
+
+   private:
+      void detach();
+
+   private:
+      PyObject* m_self;
+  };
+
+  namespace wrapper_base_
+  {
+    template <class T>
+    inline PyObject*
+    owner_impl(T const volatile* x, mpl::true_)
+    {
+        if (wrapper_base const volatile* w = dynamic_cast<wrapper_base const volatile*>(x))
+        {
+            return wrapper_base_::get_owner(*w);
+        }
+        return 0;
+    }
+
+    inline PyObject* get_owner(wrapper_base const volatile& w)
+    {
+        return w.m_self;
+    }
+  }
+
+  inline void initialize_wrapper(PyObject* self, wrapper_base* w)
+  {
+      w->m_self = self;
+  }
+
+  inline void initialize_wrapper(PyObject* , ...) {}
+
+
+
+}
+
+}}
+# 22 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/force_instantiate.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+
+
+
+
+
+template <class T>
+inline void force_instantiate(T const&) {}
+# 30 "/usr/include/boost-1_42/boost/python/detail/force_instantiate.hpp"
+}}}
+# 23 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/apply.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_fwd.hpp" 1
+# 31 "/usr/include/boost-1_42/boost/mpl/apply_fwd.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename F, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na
+    >
+struct apply;
+
+template<
+      typename F
+    >
+struct apply0;
+
+template<
+      typename F, typename T1
+    >
+struct apply1;
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply2;
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply3;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply4;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply5;
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/mpl/apply_fwd.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/arg.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/arg_fwd.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/arg_fwd.hpp"
+namespace mpl_ {
+
+template< int N > struct arg;
+
+}
+namespace boost { namespace mpl { using ::mpl_::arg; } }
+# 24 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/na_assert.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/na_assert.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/not.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/not.hpp"
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< long C_ >
+struct not_impl
+    : bool_<!C_>
+{
+};
+
+}
+
+
+template<
+      typename T = na
+    >
+struct not_
+    : aux::not_impl<
+          ::boost::mpl::aux::nested_type_wknd<T>::value
+        >
+{
+   
+};
+
+template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > : int_<1> { }; template<> struct template_arity< not_< na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/pp_counter.hpp" 1
+# 30 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 2
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 36 "/usr/include/boost-1_42/boost/mpl/assert.hpp" 2
+# 62 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
+namespace mpl_ {
+
+struct failed {};
+# 75 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
+template< bool C > struct assert { typedef void* type; };
+template<> struct assert<false> { typedef assert type; };
+
+template< bool C >
+int assertion_failed( typename assert<C>::type );
+
+template< bool C >
+struct assertion
+{
+    static int failed( assert<false> );
+};
+
+template<>
+struct assertion<true>
+{
+    static int failed( void* );
+};
+
+struct assert_
+{
+
+    template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};
+
+    static assert_ const arg;
+    enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
+};
+# 123 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
+boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
+boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
+boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
+boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
+boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );
+
+template< assert_::relations r, long x, long y > struct assert_relation {};
+
+
+
+
+
+
+template< bool > struct assert_arg_pred_impl { typedef int type; };
+template<> struct assert_arg_pred_impl<true> { typedef void* type; };
+
+template< typename P > struct assert_arg_pred
+{
+    typedef typename P::type p_type;
+    typedef typename assert_arg_pred_impl< p_type::value >::type type;
+};
+
+template< typename P > struct assert_arg_pred_not
+{
+    typedef typename P::type p_type;
+    enum { p = !p_type::value };
+    typedef typename assert_arg_pred_impl<p>::type type;
+};
+
+template< typename Pred >
+failed ************ (Pred::************
+      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
+    );
+
+template< typename Pred >
+failed ************ (boost::mpl::not_<Pred>::************
+      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
+    );
+
+template< typename Pred >
+assert<false>
+assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );
+
+template< typename Pred >
+assert<false>
+assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
+# 212 "/usr/include/boost-1_42/boost/mpl/assert.hpp"
+}
+# 24 "/usr/include/boost-1_42/boost/mpl/aux_/na_assert.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arity_spec.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arg_typedef.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/mpl/arg.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/arg.hpp"
+namespace mpl_ {
+template<> struct arg< -1 >
+{
+    static const int value = -1;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U1 type;
+        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<1>
+{
+    static const int value = 1;
+    typedef arg<2> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U1 type;
+        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<2>
+{
+    static const int value = 2;
+    typedef arg<3> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U2 type;
+        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<3>
+{
+    static const int value = 3;
+    typedef arg<4> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U3 type;
+        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<4>
+{
+    static const int value = 4;
+    typedef arg<5> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U4 type;
+        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+template<> struct arg<5>
+{
+    static const int value = 5;
+    typedef arg<6> next;
+   
+   
+
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+        typedef U5 type;
+        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))0, 1 ) ) ) };
+    };
+};
+
+
+
+}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 38 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp"
+namespace mpl_ {
+typedef arg< -1 > _;
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_;
+
+namespace placeholders {
+using mpl_::_;
+}
+
+}}
+
+
+
+namespace mpl_ {
+typedef arg<1> _1;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_1;
+
+namespace placeholders {
+using mpl_::_1;
+}
+
+}}
+namespace mpl_ {
+typedef arg<2> _2;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_2;
+
+namespace placeholders {
+using mpl_::_2;
+}
+
+}}
+namespace mpl_ {
+typedef arg<3> _3;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_3;
+
+namespace placeholders {
+using mpl_::_3;
+}
+
+}}
+namespace mpl_ {
+typedef arg<4> _4;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_4;
+
+namespace placeholders {
+using mpl_::_4;
+}
+
+}}
+namespace mpl_ {
+typedef arg<5> _5;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_5;
+
+namespace placeholders {
+using mpl_::_5;
+}
+
+}}
+namespace mpl_ {
+typedef arg<6> _6;
+
+}
+namespace boost { namespace mpl {
+
+using ::mpl_::_6;
+
+namespace placeholders {
+using mpl_::_6;
+}
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 44 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/lambda.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/lambda.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/bind.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/bind.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename F, typename T1 = na, typename T2 = na, typename T3 = na
+    , typename T4 = na, typename T5 = na
+    >
+struct bind;
+
+template<
+      typename F
+    >
+struct bind0;
+
+template<
+      typename F, typename T1
+    >
+struct bind1;
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2;
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4;
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5;
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 2
+# 24 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/protect.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/protect.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename T = na
+    , int not_le_ = 0
+    >
+struct protect : T
+{
+
+
+
+    typedef protect type;
+
+};
+# 48 "/usr/include/boost-1_42/boost/mpl/protect.hpp"
+template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };
+
+namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }
+
+
+}}
+# 27 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
+# 50 "/usr/include/boost-1_42/boost/mpl/bind.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/bind.hpp"
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template<
+      typename T, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg
+{
+    typedef T type;
+};
+
+template<
+      typename T
+    , typename Arg
+    >
+struct replace_unnamed_arg
+{
+    typedef Arg next;
+    typedef T type;
+};
+
+template<
+      typename Arg
+    >
+struct replace_unnamed_arg< arg< -1 >, Arg >
+{
+    typedef typename Arg::next next;
+    typedef Arg type;
+};
+
+template<
+      int N, typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
+{
+    typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
+{
+    typedef bind< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+template<
+      typename F
+    >
+struct bind0
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+     public:
+        typedef typename apply_wrap0<
+              f_
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind0<F>, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind0<F> f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }
+
+template<
+      typename F
+    >
+struct bind< F,na,na,na,na,na >
+    : bind0<F>
+{
+};
+
+template<
+      typename F, typename T1
+    >
+struct bind1
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+     public:
+        typedef typename apply_wrap1<
+              f_
+            , typename t1::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename U1, typename U2, typename U3
+    , typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind1< F,T1 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind1< F,T1 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }
+
+template<
+      typename F, typename T1
+    >
+struct bind< F,T1,na,na,na,na >
+    : bind1< F,T1 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind2
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+     public:
+        typedef typename apply_wrap2<
+              f_
+            , typename t1::type, typename t2::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename U1, typename U2
+    , typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind2< F,T1,T2 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind2< F,T1,T2 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct bind< F,T1,T2,na,na,na >
+    : bind2< F,T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind3
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+     public:
+        typedef typename apply_wrap3<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename U1
+    , typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind3< F,T1,T2,T3 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct bind< F,T1,T2,T3,na,na >
+    : bind3< F,T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind4
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next n5;
+        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
+
+     public:
+        typedef typename apply_wrap4<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            , typename t4::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename U1, typename U2, typename U3, typename U4, typename U5
+    >
+struct resolve_bind_arg<
+      bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind4< F,T1,T2,T3,T4 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct bind< F,T1,T2,T3,T4,na >
+    : bind4< F,T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind5
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
+        typedef typename r0::type a0;
+        typedef typename r0::next n1;
+        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;
+
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef aux::replace_unnamed_arg< T4,n4 > r4;
+        typedef typename r4::type a4;
+        typedef typename r4::next n5;
+        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;
+
+        typedef aux::replace_unnamed_arg< T5,n5 > r5;
+        typedef typename r5::type a5;
+        typedef typename r5::next n6;
+        typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;
+
+     public:
+        typedef typename apply_wrap5<
+              f_
+            , typename t1::type, typename t2::type, typename t3::type
+            , typename t4::type, typename t5::type
+            >::type type;
+
+    };
+};
+
+namespace aux {
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5, typename U1, typename U2, typename U3, typename U4
+    , typename U5
+    >
+struct resolve_bind_arg<
+      bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
+    >
+{
+    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
+    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
+};
+
+}
+
+
+namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }
+
+
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct bind
+    : bind5< F,T1,T2,T3,T4,T5 >
+{
+};
+
+
+template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
+struct quote3;
+
+template< typename T1, typename T2, typename T3 > struct if_;
+
+template<
+      typename Tag, typename T1, typename T2, typename T3
+    >
+struct bind3<
+      quote3< if_,Tag >
+    , T1, T2, T3
+    >
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef mpl::arg<1> n1;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef typename if_<
+              typename t1::type
+            , t2, t3
+            >::type f_;
+
+     public:
+        typedef typename f_::type type;
+    };
+};
+
+template<
+      template< typename T1, typename T2, typename T3 > class F, typename Tag
+    >
+struct quote3;
+
+template< typename T1, typename T2, typename T3 > struct eval_if;
+
+template<
+      typename Tag, typename T1, typename T2, typename T3
+    >
+struct bind3<
+      quote3< eval_if,Tag >
+    , T1, T2, T3
+    >
+{
+    template<
+          typename U1 = na, typename U2 = na, typename U3 = na
+        , typename U4 = na, typename U5 = na
+        >
+    struct apply
+    {
+     private:
+        typedef mpl::arg<1> n1;
+        typedef aux::replace_unnamed_arg< T1,n1 > r1;
+        typedef typename r1::type a1;
+        typedef typename r1::next n2;
+        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;
+
+        typedef aux::replace_unnamed_arg< T2,n2 > r2;
+        typedef typename r2::type a2;
+        typedef typename r2::next n3;
+        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;
+
+        typedef aux::replace_unnamed_arg< T3,n3 > r3;
+        typedef typename r3::type a3;
+        typedef typename r3::next n4;
+        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;
+
+        typedef typename eval_if<
+              typename t1::type
+            , t2, t3
+            >::type f_;
+
+     public:
+        typedef typename f_::type type;
+    };
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 51 "/usr/include/boost-1_42/boost/mpl/bind.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/mpl/lambda.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/bind_fwd.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/quote.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_type.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_type.hpp"
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+# 24 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/config/bcc.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/mpl/quote.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/quote.hpp"
+namespace boost { namespace mpl {
+
+template< typename T, bool has_type_ >
+struct quote_impl
+{
+    typedef typename T::type type;
+};
+
+template< typename T >
+struct quote_impl< T,false >
+{
+    typedef T type;
+};
+
+template<
+      template< typename P1 > class F
+    , typename Tag = void_
+    >
+struct quote1
+{
+    template< typename U1 > struct apply
+
+        : quote_impl<
+              F<U1>
+            , aux::has_type< F<U1> >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename Tag = void_
+    >
+struct quote2
+{
+    template< typename U1, typename U2 > struct apply
+
+        : quote_impl<
+              F< U1,U2 >
+            , aux::has_type< F< U1,U2 > >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename Tag = void_
+    >
+struct quote3
+{
+    template< typename U1, typename U2, typename U3 > struct apply
+
+        : quote_impl<
+              F< U1,U2,U3 >
+            , aux::has_type< F< U1,U2,U3 > >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename Tag = void_
+    >
+struct quote4
+{
+    template<
+          typename U1, typename U2, typename U3, typename U4
+        >
+    struct apply
+
+        : quote_impl<
+              F< U1,U2,U3,U4 >
+            , aux::has_type< F< U1,U2,U3,U4 > >::value
+            >
+
+    {
+    };
+};
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename Tag = void_
+    >
+struct quote5
+{
+    template<
+          typename U1, typename U2, typename U3, typename U4
+        , typename U5
+        >
+    struct apply
+
+        : quote_impl<
+              F< U1,U2,U3,U4,U5 >
+            , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
+            >
+
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 46 "/usr/include/boost-1_42/boost/mpl/quote.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/arg.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity.hpp" 1
+# 43 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< int N > struct arity_tag
+{
+    typedef char (&type)[N + 1];
+};
+
+template<
+      int C1, int C2, int C3, int C4, int C5, int C6
+    >
+struct max_arity
+{
+    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) )
+
+
+         ;
+};
+
+arity_tag<0>::type arity_helper(...);
+
+template<
+      template< typename P1 > class F
+    , typename T1
+    >
+typename arity_tag<1>::type
+arity_helper(type_wrapper< F<T1> >, arity_tag<1>);
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    >
+typename arity_tag<2>::type
+arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    >
+typename arity_tag<3>::type
+arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    >
+typename arity_tag<4>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    >
+typename arity_tag<5>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5, typename P6
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    , typename T6
+    >
+typename arity_tag<6>::type
+arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
+template< typename F, int N >
+struct template_arity_impl
+{
+    static const int value = sizeof(arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1
+
+         ;
+};
+
+template< typename F >
+struct template_arity
+{
+    static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value )
+
+
+          ;
+
+    typedef mpl::int_<value> type;
+};
+
+}}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 44 "/usr/include/boost-1_42/boost/mpl/aux_/template_arity.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
+# 44 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp"
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template<
+      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
+    , bool C5 = false
+    >
+struct lambda_or
+    : true_
+{
+};
+
+template<>
+struct lambda_or< false,false,false,false,false >
+    : false_
+{
+};
+
+}
+
+template<
+      typename T
+    , typename Tag
+    , typename Arity
+    >
+struct lambda
+{
+    typedef false_ is_le;
+    typedef T result_;
+    typedef T type;
+};
+
+template<
+      typename T
+    >
+struct is_lambda_expression
+    : lambda<T>::is_le
+{
+};
+
+template< int N, typename Tag >
+struct lambda< arg<N>,Tag, int_< -1 > >
+{
+    typedef true_ is_le;
+    typedef mpl::arg<N> result_;
+    typedef mpl::protect<result_> type;
+};
+
+template<
+      typename F
+    , typename Tag
+    >
+struct lambda<
+          bind0<F>
+        , Tag
+        , int_<1>
+        >
+{
+    typedef false_ is_le;
+    typedef bind0<
+          F
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1 > class F
+    , typename L1
+    >
+struct le_result1
+{
+    typedef F<
+          typename L1::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1 > class F
+    , typename L1
+    >
+struct le_result1< true_,Tag,F,L1 >
+{
+    typedef bind1<
+          quote1< F,Tag >
+        , typename L1::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1 > class F
+    , typename T1
+    , typename Tag
+    >
+struct lambda<
+          F<T1>
+        , Tag
+        , int_<1>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef typename l1::is_le is_le1;
+    typedef typename aux::lambda_or<
+          is_le1::value
+        >::type is_le;
+
+    typedef aux::le_result1<
+          is_le, Tag, F, l1
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1
+    , typename Tag
+    >
+struct lambda<
+          bind1< F,T1 >
+        , Tag
+        , int_<2>
+        >
+{
+    typedef false_ is_le;
+    typedef bind1<
+          F
+        , T1
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2 > class F
+    , typename L1, typename L2
+    >
+struct le_result2
+{
+    typedef F<
+          typename L1::type, typename L2::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2 > class F
+    , typename L1, typename L2
+    >
+struct le_result2< true_,Tag,F,L1,L2 >
+{
+    typedef bind2<
+          quote2< F,Tag >
+        , typename L1::result_, typename L2::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1, typename P2 > class F
+    , typename T1, typename T2
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2 >
+        , Tag
+        , int_<2>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value
+        >::type is_le;
+
+    typedef aux::le_result2<
+          is_le, Tag, F, l1, l2
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2
+    , typename Tag
+    >
+struct lambda<
+          bind2< F,T1,T2 >
+        , Tag
+        , int_<3>
+        >
+{
+    typedef false_ is_le;
+    typedef bind2<
+          F
+        , T1, T2
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2, typename P3 > class F
+    , typename L1, typename L2, typename L3
+    >
+struct le_result3
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2, typename P3 > class F
+    , typename L1, typename L2, typename L3
+    >
+struct le_result3< true_,Tag,F,L1,L2,L3 >
+{
+    typedef bind3<
+          quote3< F,Tag >
+        , typename L1::result_, typename L2::result_, typename L3::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1, typename P2, typename P3 > class F
+    , typename T1, typename T2, typename T3
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2,T3 >
+        , Tag
+        , int_<3>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+    typedef lambda< T3,Tag > l3;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+    typedef typename l3::is_le is_le3;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value, is_le3::value
+        >::type is_le;
+
+    typedef aux::le_result3<
+          is_le, Tag, F, l1, l2, l3
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    , typename Tag
+    >
+struct lambda<
+          bind3< F,T1,T2,T3 >
+        , Tag
+        , int_<4>
+        >
+{
+    typedef false_ is_le;
+    typedef bind3<
+          F
+        , T1, T2, T3
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename L1, typename L2, typename L3, typename L4
+    >
+struct le_result4
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename L1, typename L2, typename L3, typename L4
+    >
+struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
+{
+    typedef bind4<
+          quote4< F,Tag >
+        , typename L1::result_, typename L2::result_, typename L3::result_
+        , typename L4::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template< typename P1, typename P2, typename P3, typename P4 > class F
+    , typename T1, typename T2, typename T3, typename T4
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2,T3,T4 >
+        , Tag
+        , int_<4>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+    typedef lambda< T3,Tag > l3;
+    typedef lambda< T4,Tag > l4;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+    typedef typename l3::is_le is_le3;
+    typedef typename l4::is_le is_le4;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value, is_le3::value, is_le4::value
+        >::type is_le;
+
+    typedef aux::le_result4<
+          is_le, Tag, F, l1, l2, l3, l4
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename Tag
+    >
+struct lambda<
+          bind4< F,T1,T2,T3,T4 >
+        , Tag
+        , int_<5>
+        >
+{
+    typedef false_ is_le;
+    typedef bind4<
+          F
+        , T1, T2, T3, T4
+        > result_;
+
+    typedef result_ type;
+};
+
+namespace aux {
+
+template<
+      typename IsLE, typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
+    , typename L1, typename L2, typename L3, typename L4, typename L5
+    >
+struct le_result5
+{
+    typedef F<
+          typename L1::type, typename L2::type, typename L3::type
+        , typename L4::type, typename L5::type
+        > result_;
+
+    typedef result_ type;
+};
+
+template<
+      typename Tag
+    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
+    , typename L1, typename L2, typename L3, typename L4, typename L5
+    >
+struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
+{
+    typedef bind5<
+          quote5< F,Tag >
+        , typename L1::result_, typename L2::result_, typename L3::result_
+        , typename L4::result_, typename L5::result_
+        > result_;
+
+    typedef mpl::protect<result_> type;
+};
+
+}
+
+template<
+      template<
+          typename P1, typename P2, typename P3, typename P4
+        , typename P5
+        >
+      class F
+    , typename T1, typename T2, typename T3, typename T4, typename T5
+    , typename Tag
+    >
+struct lambda<
+          F< T1,T2,T3,T4,T5 >
+        , Tag
+        , int_<5>
+        >
+{
+    typedef lambda< T1,Tag > l1;
+    typedef lambda< T2,Tag > l2;
+    typedef lambda< T3,Tag > l3;
+    typedef lambda< T4,Tag > l4;
+    typedef lambda< T5,Tag > l5;
+
+    typedef typename l1::is_le is_le1;
+    typedef typename l2::is_le is_le2;
+    typedef typename l3::is_le is_le3;
+    typedef typename l4::is_le is_le4;
+    typedef typename l5::is_le is_le5;
+
+
+    typedef typename aux::lambda_or<
+          is_le1::value, is_le2::value, is_le3::value, is_le4::value
+        , is_le5::value
+        >::type is_le;
+
+    typedef aux::le_result5<
+          is_le, Tag, F, l1, l2, l3, l4, l5
+        > le_result_;
+
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    , typename Tag
+    >
+struct lambda<
+          bind5< F,T1,T2,T3,T4,T5 >
+        , Tag
+        , int_<6>
+        >
+{
+    typedef false_ is_le;
+    typedef bind5<
+          F
+        , T1, T2, T3, T4, T5
+        > result_;
+
+    typedef result_ type;
+};
+
+
+template< typename T, typename Tag >
+struct lambda< mpl::protect<T>,Tag, int_<1> >
+{
+    typedef false_ is_le;
+    typedef mpl::protect<T> result_;
+    typedef result_ type;
+};
+
+
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    , typename Tag
+    >
+struct lambda<
+          bind< F,T1,T2,T3,T4,T5 >
+        , Tag
+        , int_<6>
+        >
+{
+    typedef false_ is_le;
+    typedef bind< F,T1,T2,T3,T4,T5 > result_;
+    typedef result_ type;
+};
+
+template<
+      typename F
+    , typename Tag1
+    , typename Tag2
+    , typename Arity
+    >
+struct lambda<
+          lambda< F,Tag1,Arity >
+        , Tag2
+        , int_<3>
+        >
+{
+    typedef lambda< F,Tag2 > l1;
+    typedef lambda< Tag1,Tag2 > l2;
+    typedef typename l1::is_le is_le;
+    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
+    typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
+    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
+    typedef typename le_result_::result_ result_;
+    typedef typename le_result_::type type;
+};
+
+template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/mpl/aux_/full_lambda.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/mpl/lambda.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/mpl/apply.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/apply.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename F
+    >
+struct apply0
+
+    : apply_wrap0<
+          typename lambda<F>::type
+
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F
+    >
+struct apply< F,na,na,na,na,na >
+    : apply0<F>
+{
+};
+
+template<
+      typename F, typename T1
+    >
+struct apply1
+
+    : apply_wrap1<
+          typename lambda<F>::type
+        , T1
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1
+    >
+struct apply< F,T1,na,na,na,na >
+    : apply1< F,T1 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply2
+
+    : apply_wrap2<
+          typename lambda<F>::type
+        , T1, T2
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1, typename T2
+    >
+struct apply< F,T1,T2,na,na,na >
+    : apply2< F,T1,T2 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply3
+
+    : apply_wrap3<
+          typename lambda<F>::type
+        , T1, T2, T3
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3
+    >
+struct apply< F,T1,T2,T3,na,na >
+    : apply3< F,T1,T2,T3 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply4
+
+    : apply_wrap4<
+          typename lambda<F>::type
+        , T1, T2, T3, T4
+        >
+{
+   
+
+
+
+
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    >
+struct apply< F,T1,T2,T3,T4,na >
+    : apply4< F,T1,T2,T3,T4 >
+{
+};
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply5
+
+    : apply_wrap5<
+          typename lambda<F>::type
+        , T1, T2, T3, T4, T5
+        >
+{
+   
+
+
+
+
+};
+
+
+
+template<
+      typename F, typename T1, typename T2, typename T3, typename T4
+    , typename T5
+    >
+struct apply
+    : apply5< F,T1,T2,T3,T4,T5 >
+{
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/debug/line.hpp" 1
+# 33 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+
+
+
+
+
+namespace boost { namespace python {
+
+template <class T> class wrapper;
+
+}}
+
+
+namespace boost { namespace python { namespace objects {
+
+
+
+
+
+
+
+template <class Pointer, class Value>
+struct pointer_holder : instance_holder
+{
+    typedef Value value_type;
+
+    pointer_holder(Pointer);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+
+
+    pointer_holder(PyObject* self )
+        : m_p(new Value(
+               
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 >
+
+    pointer_holder(PyObject* self , A0 a0)
+        : m_p(new Value(
+                objects::do_unforward(a0,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 179 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template< class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 >
+
+    pointer_holder(PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
+        : m_p(new Value(
+                objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
+            ))
+    {
+        python::detail::initialize_wrapper(self, get_pointer(this->m_p));
+    }
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 64 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+
+ private:
+
+ private:
+    void* holds(type_info, bool null_ptr_only);
+
+    template <class T>
+    inline void* holds_wrapped(type_info dst_t, wrapper<T>*,T* p)
+    {
+        return python::type_id<T>() == dst_t ? p : 0;
+    }
+
+    inline void* holds_wrapped(type_info, ...)
+    {
+        return 0;
+    }
+
+ private:
+    Pointer m_p;
+};
+
+template <class Pointer, class Value>
+struct pointer_holder_back_reference : instance_holder
+{
+ private:
+    typedef typename python::pointee<Pointer>::type held_type;
+ public:
+    typedef Value value_type;
+
+
+
+    pointer_holder_back_reference(Pointer);
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+
+
+    pointer_holder_back_reference(
+        PyObject* p )
+        : m_p(new held_type(
+                    p
+            ))
+    {}
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0)
+            ))
+    {}
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
+            ))
+    {}
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
+            ))
+    {}
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
+            ))
+    {}
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
+            ))
+    {}
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
+            ))
+    {}
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
+            ))
+    {}
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
+            ))
+    {}
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
+            ))
+    {}
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
+            ))
+    {}
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
+            ))
+    {}
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
+            ))
+    {}
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
+            ))
+    {}
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
+            ))
+    {}
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 201 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14 >
+
+    pointer_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
+        : m_p(new held_type(
+                    p , objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
+            ))
+    {}
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 100 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 2
+
+ private:
+    void* holds(type_info, bool null_ptr_only);
+
+ private:
+    Pointer m_p;
+};
+
+
+
+template <class Pointer, class Value>
+inline pointer_holder<Pointer,Value>::pointer_holder(Pointer p)
+    : m_p(p)
+{
+}
+
+template <class Pointer, class Value>
+inline pointer_holder_back_reference<Pointer,Value>::pointer_holder_back_reference(Pointer p)
+    : m_p(p)
+{
+}
+
+template <class Pointer, class Value>
+void* pointer_holder<Pointer, Value>::holds(type_info dst_t, bool null_ptr_only)
+{
+    if (dst_t == python::type_id<Pointer>()
+        && !(null_ptr_only && get_pointer(this->m_p))
+    )
+        return &this->m_p;
+
+    Value* p
+
+
+
+        = get_pointer(this->m_p)
+
+        ;
+
+    if (p == 0)
+        return 0;
+
+    if (void* wrapped = holds_wrapped(dst_t, p, p))
+        return wrapped;
+
+    type_info src_t = python::type_id<Value>();
+    return src_t == dst_t ? p : find_dynamic_type(p, src_t, dst_t);
+}
+
+template <class Pointer, class Value>
+void* pointer_holder_back_reference<Pointer, Value>::holds(type_info dst_t, bool null_ptr_only)
+{
+    if (dst_t == python::type_id<Pointer>()
+        && !(null_ptr_only && get_pointer(this->m_p))
+    )
+        return &this->m_p;
+
+    if (!get_pointer(this->m_p))
+        return 0;
+
+    Value* p = get_pointer(m_p);
+
+    if (dst_t == python::type_id<held_type>())
+        return p;
+
+    type_info src_t = python::type_id<Value>();
+    return src_t == dst_t ? p : find_dynamic_type(p, src_t, dst_t);
+}
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/make_ptr_instance.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/instance.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/object/instance.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/alignment_traits.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/alignment_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/for_each_i.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/list/for_each_i.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/detail/auto_rec.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp" 2
+# 42 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/detail/for.hpp" 1
+# 43 "/usr/include/boost-1_42/boost/preprocessor/repetition/for.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/preprocessor/list/for_each_i.hpp" 2
+# 13 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/to_list.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/transform.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/list/append.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 24 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 26 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
+
+
+
+
+
+
+namespace boost {
+
+
+
+namespace detail {
+
+class alignment_dummy;
+typedef void (*function_ptr)();
+typedef int (alignment_dummy::*member_ptr);
+typedef int (alignment_dummy::*member_function_ptr)();
+# 101 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
+template <bool found, std::size_t target, class TestType>
+struct lower_alignment_helper
+{
+    typedef char type;
+    enum { value = true };
+};
+
+template <std::size_t target, class TestType>
+struct lower_alignment_helper<false,target,TestType>
+{
+    enum { value = (alignment_of<TestType>::value == target) };
+    typedef typename mpl::if_c<value, TestType, char>::type type;
+};
+# 127 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
+template <typename T>
+struct has_one_T
+{
+  T data;
+};
+
+template <std::size_t target>
+union lower_alignment
+{
+    enum { found0 = false };
+
+   
+
+
+
+ typename lower_alignment_helper< found0,target,char >::type t0; enum { found1 = lower_alignment_helper<found0,target,char >::value }; typename lower_alignment_helper< found1,target,short >::type t1; enum { found2 = lower_alignment_helper<found1,target,short >::value }; typename lower_alignment_helper< found2,target,int >::type t2; enum { found3 = lower_alignment_helper<found2,target,int >::value }; typename lower_alignment_helper< found3,target,long >::type t3; enum { found4 = lower_alignment_helper<found3,target,long >::value }; typename lower_alignment_helper< found4,target,::boost::long_long_type >::type t4; enum { found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value }; typename lower_alignment_helper< found5,target,float >::type t5; enum { found6 = lower_alignment_helper<found5,target,float >::value }; typename lower_alignment_helper< found6,target,double >::type t6; enum { found7 = lower_alignment_helper<found6,target,double >::value }; typename lower_alignment_helper< found7,target,long double >::type t7; enum { found8 = lower_alignment_helper<found7,target,long double >::value }; typename lower_alignment_helper< found8,target,void* >::type t8; enum { found9 = lower_alignment_helper<found8,target,void* >::value }; typename lower_alignment_helper< found9,target,function_ptr >::type t9; enum { found10 = lower_alignment_helper<found9,target,function_ptr >::value }; typename lower_alignment_helper< found10,target,member_ptr >::type t10; enum { found11 = lower_alignment_helper<found10,target,member_ptr >::value }; typename lower_alignment_helper< found11,target,member_function_ptr >::type t11; enum { found12 = lower_alignment_helper<found11,target,member_function_ptr >::value }; typename lower_alignment_helper< found12,target,boost::detail::has_one_T< char > >::type t12; enum { found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value }; typename lower_alignment_helper< found13,target,boost::detail::has_one_T< short > >::type t13; enum { found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value }; typename lower_alignment_helper< found14,target,boost::detail::has_one_T< int > >::type t14; enum { found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value }; typename lower_alignment_helper< found15,target,boost::detail::has_one_T< long > >::type t15; enum { found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value }; typename lower_alignment_helper< found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::type t16; enum { found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value }; typename lower_alignment_helper< found17,target,boost::detail::has_one_T< float > >::type t17; enum { found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value }; typename lower_alignment_helper< found18,target,boost::detail::has_one_T< double > >::type t18; enum { found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T< double > >::value }; typename lower_alignment_helper< found19,target,boost::detail::has_one_T< long double > >::type t19; enum { found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value }; typename lower_alignment_helper< found20,target,boost::detail::has_one_T< void* > >::type t20; enum { found21 = lower_alignment_helper<found20,target,boost::detail::has_one_T< void* > >::value }; typename lower_alignment_helper< found21,target,boost::detail::has_one_T< function_ptr > >::type t21; enum { found22 = lower_alignment_helper<found21,target,boost::detail::has_one_T< function_ptr > >::value }; typename lower_alignment_helper< found22,target,boost::detail::has_one_T< member_ptr > >::type t22; enum { found23 = lower_alignment_helper<found22,target,boost::detail::has_one_T< member_ptr > >::value }; typename lower_alignment_helper< found23,target,boost::detail::has_one_T< member_function_ptr > >::type t23; enum { found24 = lower_alignment_helper<found23,target,boost::detail::has_one_T< member_function_ptr > >::value };
+};
+
+union max_align
+{
+   
+
+
+
+ char t0; short t1; int t2; long t3; ::boost::long_long_type t4; float t5; double t6; long double t7; void* t8; function_ptr t9; member_ptr t10; member_function_ptr t11; boost::detail::has_one_T< char > t12; boost::detail::has_one_T< short > t13; boost::detail::has_one_T< int > t14; boost::detail::has_one_T< long > t15; boost::detail::has_one_T< ::boost::long_long_type > t16; boost::detail::has_one_T< float > t17; boost::detail::has_one_T< double > t18; boost::detail::has_one_T< long double > t19; boost::detail::has_one_T< void* > t20; boost::detail::has_one_T< function_ptr > t21; boost::detail::has_one_T< member_ptr > t22; boost::detail::has_one_T< member_function_ptr > t23;
+};
+# 161 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
+template<std::size_t TAlign, std::size_t Align>
+struct is_aligned
+{
+    static const bool value = (TAlign >= Align) & (TAlign % Align == 0)
+
+         ;
+};
+# 180 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
+}
+
+
+template<std::size_t Align>
+struct is_pod< ::boost::detail::lower_alignment<Align> >
+{
+        static const std::size_t value = true;
+};
+
+
+
+
+namespace detail{
+
+template <std::size_t Align>
+class type_with_alignment_imp
+{
+    typedef ::boost::detail::lower_alignment<Align> t1;
+    typedef typename mpl::if_c<
+          ::boost::detail::is_aligned< ::boost::alignment_of<t1>::value,Align >::value
+        , t1
+        , ::boost::detail::max_align
+        >::type align_t;
+
+    static const std::size_t found = alignment_of<align_t>::value;
+
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found >= Align) == 0 ? false : true) >)> boost_static_assert_typedef_206;
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((found % Align == 0) == 0 ? false : true) >)> boost_static_assert_typedef_207;
+
+ public:
+    typedef align_t type;
+};
+
+}
+
+template <std::size_t Align>
+class type_with_alignment
+  : public ::boost::detail::type_with_alignment_imp<Align>
+{
+};
+
+
+namespace align {
+struct __attribute__((__aligned__(2))) a2 {};
+struct __attribute__((__aligned__(4))) a4 {};
+struct __attribute__((__aligned__(8))) a8 {};
+struct __attribute__((__aligned__(16))) a16 {};
+struct __attribute__((__aligned__(32))) a32 {};
+}
+
+template<> class type_with_alignment<1> { public: typedef char type; };
+template<> class type_with_alignment<2> { public: typedef align::a2 type; };
+template<> class type_with_alignment<4> { public: typedef align::a4 type; };
+template<> class type_with_alignment<8> { public: typedef align::a8 type; };
+template<> class type_with_alignment<16> { public: typedef align::a16 type; };
+template<> class type_with_alignment<32> { public: typedef align::a32 type; };
+
+namespace detail {
+template<> struct is_pod_impl< ::boost::align::a2 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a4 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a8 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a16 > { static const bool value = (true); };
+template<> struct is_pod_impl< ::boost::align::a32 > { static const bool value = (true); };
+}
+# 383 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp"
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 390 "/usr/include/boost-1_42/boost/type_traits/type_with_alignment.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/alignment_traits.hpp" 2
+# 10 "/usr/include/boost-1_42/boost/python/object/instance.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 11 "/usr/include/boost-1_42/boost/python/object/instance.hpp" 2
+
+namespace boost { namespace python
+{
+  struct instance_holder;
+}}
+
+namespace boost { namespace python { namespace objects {
+
+
+template <class Data = char>
+struct instance
+{
+    Py_ssize_t ob_refcnt; struct _typeobject *ob_type; Py_ssize_t ob_size;
+    PyObject* dict;
+    PyObject* weakrefs;
+    instance_holder* objects;
+
+    typedef typename type_with_alignment<
+        ::boost::alignment_of<Data>::value
+    >::type align_t;
+
+    union
+    {
+        align_t align;
+        char bytes[sizeof(Data)];
+    } storage;
+};
+
+template <class Data>
+struct additional_instance_size
+{
+    typedef instance<Data> instance_data;
+    typedef instance<char> instance_char;
+    static const std::size_t value = sizeof(instance_data) - __builtin_offsetof (instance_char, storage)
+
+                                                                          ;
+};
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/to_python_function_type.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/converter/to_python_function_type.hpp"
+namespace boost { namespace python { namespace converter {
+
+
+
+
+typedef PyObject* (*to_python_function_t)(void const*);
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/constructor_function.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace converter {
+
+
+
+struct rvalue_from_python_stage1_data;
+typedef void (*constructor_function)(PyObject* source, rvalue_from_python_stage1_data*);
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/referent_storage.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 9 "/usr/include/boost-1_42/boost/python/detail/referent_storage.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+struct alignment_dummy;
+typedef void (*function_ptr)();
+typedef int (alignment_dummy::*member_ptr);
+typedef int (alignment_dummy::*member_function_ptr)();
+
+
+
+
+
+
+template <std::size_t size>
+union aligned_storage
+{
+    typename mpl::if_c< sizeof(char) <= size, char, char>::type t0;
+    typename mpl::if_c< sizeof(short) <= size, short, char>::type t1;
+    typename mpl::if_c< sizeof(int) <= size, int, char>::type t2;
+    typename mpl::if_c< sizeof(long) <= size, long, char>::type t3;
+    typename mpl::if_c< sizeof(float) <= size, float, char>::type t4;
+    typename mpl::if_c< sizeof(double) <= size, double, char>::type t5;
+    typename mpl::if_c< sizeof(long double) <= size, long double, char>::type t6;
+    typename mpl::if_c< sizeof(void*) <= size, void*, char>::type t7;
+    typename mpl::if_c< sizeof(function_ptr) <= size, function_ptr, char>::type t8;
+    typename mpl::if_c< sizeof(member_ptr) <= size, member_ptr, char>::type t9;
+    typename mpl::if_c< sizeof(member_function_ptr) <= size, member_function_ptr, char>::type t10;
+    char bytes[size];
+};
+
+
+
+
+
+  template <class T> struct referent_size;
+
+
+
+  template <class T>
+  struct referent_size<T&>
+  {
+      static const std::size_t value = sizeof(T)
+                                         ;
+  };
+# 66 "/usr/include/boost-1_42/boost/python/detail/referent_storage.hpp"
+template <class T>
+struct referent_storage
+{
+    typedef aligned_storage<
+        ::boost::python::detail::referent_size<T>::value
+    > type;
+};
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/destroy.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/detail/destroy.hpp"
+namespace boost { namespace python { namespace detail {
+
+template <
+    bool array
+
+
+
+    > struct value_destroyer;
+
+template <>
+struct value_destroyer<
+    false
+
+
+
+    >
+{
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        p->T::~T();
+    }
+};
+
+template <>
+struct value_destroyer<
+    true
+
+
+
+    >
+{
+    template <class A, class T>
+    static void execute(A*, T const volatile* const first)
+    {
+        for (T const volatile* p = first; p != first + sizeof(A)/sizeof(T); ++p)
+        {
+            value_destroyer<
+                boost::is_array<T>::value
+
+
+
+            >::execute(p);
+        }
+    }
+
+    template <class T>
+    static void execute(T const volatile* p)
+    {
+        execute(p, *p);
+    }
+};
+# 85 "/usr/include/boost-1_42/boost/python/detail/destroy.hpp"
+template <class T>
+inline void destroy_referent_impl(void* p, T& (*)())
+{
+
+
+    value_destroyer<
+         (boost::is_array<T>::value)
+
+
+
+    >::execute((const volatile T*)p);
+}
+
+template <class T>
+inline void destroy_referent(void* p, T(*)() = 0)
+{
+    destroy_referent_impl(p, (T(*)())0);
+}
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 15 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp" 2
+# 39 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp"
+namespace boost { namespace python { namespace converter {
+# 62 "/usr/include/boost-1_42/boost/python/converter/rvalue_from_python_data.hpp"
+struct rvalue_from_python_stage1_data
+{
+    void* convertible;
+    constructor_function construct;
+};
+
+
+
+
+
+
+
+template <class T>
+struct rvalue_from_python_storage
+{
+    rvalue_from_python_stage1_data stage1;
+
+
+    typename python::detail::referent_storage<
+        typename add_reference<T>::type
+    >::type storage;
+};
+
+
+
+
+
+
+
+template <class T>
+struct rvalue_from_python_data : rvalue_from_python_storage<T>
+{
+
+
+
+
+
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((__builtin_offsetof (rvalue_from_python_storage<T>, stage1) == 0) == 0 ? false : true) >)> boost_static_assert_typedef_99;
+
+
+
+    rvalue_from_python_data(rvalue_from_python_stage1_data const&);
+
+
+
+
+    rvalue_from_python_data(void* convertible);
+
+
+    ~rvalue_from_python_data();
+ private:
+    typedef typename add_reference<typename add_cv<T>::type>::type ref_type;
+};
+
+
+
+
+template <class T>
+inline rvalue_from_python_data<T>::rvalue_from_python_data(rvalue_from_python_stage1_data const& _stage1)
+{
+    this->stage1 = _stage1;
+}
+
+template <class T>
+inline rvalue_from_python_data<T>::rvalue_from_python_data(void* convertible)
+{
+    this->stage1.convertible = convertible;
+}
+
+template <class T>
+inline rvalue_from_python_data<T>::~rvalue_from_python_data()
+{
+    if (this->stage1.convertible == this->storage.bytes)
+        python::detail::destroy_referent<ref_type>(this->storage.bytes);
+}
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/convertible_function.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace converter {
+
+typedef void* (*convertible_function)(PyObject*);
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/converter/registry.hpp" 2
+
+namespace boost { namespace python { namespace converter {
+
+struct registration;
+
+
+namespace registry
+{
+
+  registration const& lookup(type_info);
+
+
+
+  registration const& lookup_shared_ptr(type_info);
+
+
+  registration const* query(type_info);
+
+  void insert(to_python_function_t, type_info, PyTypeObject const* (*to_python_target_type)() = 0);
+
+
+  void insert(void* (*convert)(PyObject*), type_info, PyTypeObject const* (*expected_pytype)() = 0);
+
+
+  void insert(
+      convertible_function
+      , constructor_function
+      , type_info
+      , PyTypeObject const* (*expected_pytype)() = 0
+      );
+
+
+
+  void push_back(
+      convertible_function
+      , constructor_function
+      , type_info
+      , PyTypeObject const* (*expected_pytype)() = 0
+      );
+}
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/converter/registrations.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/python/converter/registrations.hpp"
+namespace boost { namespace python { namespace converter {
+
+struct lvalue_from_python_chain
+{
+    convertible_function convert;
+    lvalue_from_python_chain* next;
+};
+
+struct rvalue_from_python_chain
+{
+    convertible_function convertible;
+    constructor_function construct;
+    PyTypeObject const* (*expected_pytype)();
+    rvalue_from_python_chain* next;
+};
+
+struct registration
+{
+ public:
+    explicit registration(type_info target, bool is_shared_ptr = false);
+   ~registration();
+
+
+    PyObject* to_python(void const volatile*) const;
+
+
+
+    PyTypeObject* get_class_object() const;
+
+
+
+    PyTypeObject const* expected_from_python_type() const;
+    PyTypeObject const* to_python_target_type() const;
+
+ public:
+    const python::type_info target_type;
+
+
+    lvalue_from_python_chain* lvalue_chain;
+
+
+    rvalue_from_python_chain* rvalue_chain;
+
+
+    PyTypeObject* m_class_object;
+
+
+    to_python_function_t m_to_python;
+    PyTypeObject const* (*m_to_python_target_type)();
+
+
+
+
+    const bool is_shared_ptr;
+
+
+
+
+
+};
+
+
+
+
+inline registration::registration(type_info target_type, bool is_shared_ptr)
+    : target_type(target_type)
+      , lvalue_chain(0)
+      , rvalue_chain(0)
+      , m_class_object(0)
+      , m_to_python(0)
+      , m_to_python_target_type(0)
+      , is_shared_ptr(is_shared_ptr)
+{}
+
+inline bool operator<(registration const& lhs, registration const& rhs)
+{
+    return lhs.target_type < rhs.target_type;
+}
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp" 2
+
+namespace boost {
+
+namespace detail {
+# 55 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp"
+template <typename T>
+struct add_pointer_impl
+{
+    typedef typename remove_reference<T>::type no_ref_type;
+    typedef no_ref_type* type;
+};
+
+
+
+}
+
+template< typename T > struct add_pointer { typedef typename boost::detail::add_pointer_impl<T>::type type; };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 71 "/usr/include/boost-1_42/boost/type_traits/add_pointer.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 14 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 2
+
+
+
+namespace boost {
+
+template< typename T > struct remove_bounds { typedef T type; };
+
+
+template< typename T, std::size_t N > struct remove_bounds<T[N]> { typedef T type; };
+template< typename T, std::size_t N > struct remove_bounds<T const[N]> { typedef T const type; };
+template< typename T, std::size_t N > struct remove_bounds<T volatile[N]> { typedef T volatile type; };
+template< typename T, std::size_t N > struct remove_bounds<T const volatile[N]> { typedef T const volatile type; };
+
+template< typename T > struct remove_bounds<T[]> { typedef T type; };
+template< typename T > struct remove_bounds<T const[]> { typedef T const type; };
+template< typename T > struct remove_bounds<T volatile[]> { typedef T volatile type; };
+template< typename T > struct remove_bounds<T const volatile[]> { typedef T const volatile type; };
+
+
+
+}
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/type_traits/remove_bounds.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/type_traits/transform_traits.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/python/converter/registered.hpp" 2
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+template <class T> class shared_ptr;
+
+namespace python { namespace converter {
+
+struct registration;
+
+namespace detail
+{
+  template <class T>
+  struct registered_base
+  {
+      static registration const& converters;
+  };
+}
+
+template <class T>
+struct registered
+  : detail::registered_base<
+        typename add_reference<
+            typename add_cv<T>::type
+        >::type
+    >
+{
+};
+
+
+
+
+
+
+
+template <class T>
+struct registered<T&>
+  : registered<T> {};
+
+
+
+
+
+namespace detail
+{
+  inline void
+  register_shared_ptr0(...)
+  {
+  }
+
+  template <class T>
+  inline void
+  register_shared_ptr0(shared_ptr<T>*)
+  {
+      registry::lookup_shared_ptr(type_id<shared_ptr<T> >());
+  }
+
+  template <class T>
+  inline void
+  register_shared_ptr1(T const volatile*)
+  {
+      detail::register_shared_ptr0((T*)0);
+  }
+
+  template <class T>
+  inline registration const&
+  registry_lookup2(T&(*)())
+  {
+      detail::register_shared_ptr1((T*)0);
+      return registry::lookup(type_id<T&>());
+  }
+
+  template <class T>
+  inline registration const&
+  registry_lookup1(type<T>)
+  {
+      return registry_lookup2((T(*)())0);
+  }
+
+  inline registration const&
+  registry_lookup1(type<const volatile void>)
+  {
+      detail::register_shared_ptr1((void*)0);
+      return registry::lookup(type_id<void>());
+  }
+
+  template <class T>
+  registration const& registered_base<T>::converters = detail::registry_lookup1(type<T>());
+
+}
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/decref_guard.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+struct decref_guard
+{
+    decref_guard(PyObject* o) : obj(o) {}
+    ~decref_guard() { if ((obj) == __null) ; else if ( --((PyObject*)(obj))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(obj)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(obj)))); }
+    void cancel() { obj = 0; }
+ private:
+    PyObject* obj;
+};
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/none.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/detail/none.hpp"
+namespace boost { namespace python { namespace detail {
+
+inline PyObject* none() { ( ((PyObject*)((&_Py_NoneStruct)))->ob_refcnt++); return (&_Py_NoneStruct); }
+
+}}}
+# 13 "/usr/include/boost-1_42/boost/python/object/make_instance.hpp" 2
+
+namespace boost { namespace python { namespace objects {
+
+template <class T, class Holder, class Derived>
+struct make_instance_impl
+{
+    typedef objects::instance<Holder> instance_t;
+
+    template <class Arg>
+    static inline PyObject* execute(Arg& x)
+    {
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((is_class<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_24;
+
+        PyTypeObject* type = Derived::get_class_object(x);
+
+        if (type == 0)
+            return python::detail::none();
+
+        PyObject* raw_result = type->tp_alloc(
+            type, objects::additional_instance_size<Holder>::value);
+
+        if (raw_result != 0)
+        {
+            python::detail::decref_guard protect(raw_result);
+
+            instance_t* instance = (instance_t*)raw_result;
+
+
+
+            Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result);
+
+
+
+            (((PyVarObject*)(instance))->ob_size) = __builtin_offsetof (instance_t, storage);
+
+
+            protect.cancel();
+        }
+        return raw_result;
+    }
+};
+
+
+template <class T, class Holder>
+struct make_instance
+    : make_instance_impl<T, Holder, make_instance<T,Holder> >
+{
+    template <class U>
+    static inline PyTypeObject* get_class_object(U&)
+    {
+        return converter::registered<T>::converters.get_class_object();
+    }
+
+    static inline Holder* construct(void* storage, PyObject* instance, reference_wrapper<T const> x)
+    {
+        return new (storage) Holder(instance, x);
+    }
+};
+
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/object/make_ptr_instance.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace python { namespace objects {
+
+template <class T, class Holder>
+struct make_ptr_instance
+    : make_instance_impl<T, Holder, make_ptr_instance<T,Holder> >
+{
+    template <class Arg>
+    static inline Holder* construct(void* storage, PyObject*, Arg& x)
+    {
+        return new (storage) Holder(x);
+    }
+
+    template <class Ptr>
+    static inline PyTypeObject* get_class_object(Ptr const& x)
+    {
+        return get_class_object_impl(get_pointer(x));
+    }
+
+    static inline PyTypeObject const* get_pytype()
+    {
+        return converter::registered<T>::converters.get_class_object();
+    }
+
+ private:
+    template <class U>
+    static inline PyTypeObject* get_class_object_impl(U const volatile* p)
+    {
+        if (p == 0)
+            return 0;
+
+        PyTypeObject* derived = get_derived_class_object(
+            typename is_polymorphic<U>::type(), p);
+
+        if (derived)
+            return derived;
+        return converter::registered<T>::converters.get_class_object();
+    }
+
+    template <class U>
+    static inline PyTypeObject* get_derived_class_object(mpl::true_, U const volatile* x)
+    {
+        converter::registration const* r = converter::registry::query(
+            type_info(typeid(*get_pointer(x)))
+        );
+        return r ? r->m_class_object : 0;
+    }
+
+    template <class U>
+    static inline PyTypeObject* get_derived_class_object(mpl::false_, U*)
+    {
+        return 0;
+    }
+};
+
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/pytype_function.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/converter/pytype_function.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/cv_category.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/detail/cv_category.hpp"
+namespace boost { namespace python { namespace detail {
+
+template <bool is_const_, bool is_volatile_>
+struct cv_tag
+{
+    static const bool is_const = is_const_;
+    static const bool is_volatile = is_const_;
+};
+
+typedef cv_tag<false,false> cv_unqualified;
+typedef cv_tag<true,false> const_;
+typedef cv_tag<false,true> volatile_;
+typedef cv_tag<true,true> const_volatile_;
+
+template <class T>
+struct cv_category
+{
+
+
+    typedef cv_tag<
+        ::boost::is_const<T>::value
+      , ::boost::is_volatile<T>::value
+    > type;
+};
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/indirect_traits.hpp" 1
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/and.hpp" 1
+# 42 "/usr/include/boost-1_42/boost/mpl/and.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/and.hpp"
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool C_, typename T1, typename T2, typename T3, typename T4 >
+struct and_impl
+    : false_
+{
+};
+
+template< typename T1, typename T2, typename T3, typename T4 >
+struct and_impl< true,T1,T2,T3,T4 >
+    : and_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4
+        , true_
+        >
+{
+};
+
+template<>
+struct and_impl<
+          true
+        , true_, true_, true_, true_
+        >
+    : true_
+{
+};
+
+}
+
+template<
+      typename T1 = na
+    , typename T2 = na
+    , typename T3 = true_, typename T4 = true_, typename T5 = true_
+    >
+struct and_
+
+    : aux::and_impl<
+          ::boost::mpl::aux::nested_type_wknd<T1>::value
+        , T2, T3, T4, T5
+        >
+
+{
+   
+
+
+
+
+};
+
+template<> struct and_<
+
+
+
+ na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/mpl/and.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp" 2
+
+
+
+
+
+
+
+namespace boost { namespace detail {
+
+namespace indirect_traits {
+
+
+template <class T>
+struct is_reference_to_const : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_const<T const&> : mpl::true_
+{
+};
+# 55 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
+template <class T>
+struct is_reference_to_function : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_function<T&> : is_function<T>
+{
+};
+
+template <class T>
+struct is_pointer_to_function : mpl::false_
+{
+};
+
+
+
+template <class T>
+struct is_pointer_to_function<T*> : is_function<T>
+{
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer_impl : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_member_function_pointer_impl<T&>
+    : is_member_function_pointer<typename remove_cv<T>::type>
+{
+};
+
+
+template <class T>
+struct is_reference_to_member_function_pointer
+    : is_reference_to_member_function_pointer_impl<T>
+{
+   
+};
+
+template <class T>
+struct is_reference_to_function_pointer_aux
+    : mpl::and_<
+          is_reference<T>
+        , is_pointer_to_function<
+              typename remove_cv<
+                  typename remove_reference<T>::type
+              >::type
+          >
+      >
+{
+
+};
+
+template <class T>
+struct is_reference_to_function_pointer
+    : mpl::if_<
+          is_reference_to_function<T>
+        , mpl::false_
+        , is_reference_to_function_pointer_aux<T>
+     >::type
+{
+};
+
+template <class T>
+struct is_reference_to_non_const
+    : mpl::and_<
+          is_reference<T>
+        , mpl::not_<
+             is_reference_to_const<T>
+          >
+      >
+{
+};
+
+template <class T>
+struct is_reference_to_volatile : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_volatile<T volatile&> : mpl::true_
+{
+};
+# 149 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
+template <class T>
+struct is_reference_to_pointer : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T*&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* volatile&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_pointer<T* const volatile&> : mpl::true_
+{
+};
+
+template <class T>
+struct is_reference_to_class
+    : mpl::and_<
+          is_reference<T>
+        , is_class<
+              typename remove_cv<
+                  typename remove_reference<T>::type
+              >::type
+          >
+      >
+{
+   
+};
+
+template <class T>
+struct is_pointer_to_class
+    : mpl::and_<
+          is_pointer<T>
+        , is_class<
+              typename remove_cv<
+                  typename remove_pointer<T>::type
+              >::type
+          >
+      >
+{
+   
+};
+# 481 "/usr/include/boost-1_42/boost/detail/indirect_traits.hpp"
+}
+
+using namespace indirect_traits;
+
+}}
+# 8 "/usr/include/boost-1_42/boost/python/detail/indirect_traits.hpp" 2
+
+namespace boost { namespace python {
+namespace indirect_traits = boost::detail::indirect_traits;
+}}
+# 10 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp" 2
+
+
+namespace boost { namespace python { namespace detail {
+
+
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type(U const& p, Generator* = 0);
+
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type(boost::type<U>*p = 0, Generator* = 0);
+
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U* p, cv_unqualified, Generator* = 0)
+{
+    return Generator::execute(p);
+}
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U const* p, const_, Generator* = 0)
+{
+    return unwind_type(const_cast<U*>(p), (Generator*)0);
+}
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U volatile* p, volatile_, Generator* = 0)
+{
+    return unwind_type(const_cast<U*>(p), (Generator*)0);
+}
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_type_cv(U const volatile* p, const_volatile_, Generator* = 0)
+{
+    return unwind_type(const_cast<U*>(p), (Generator*)0);
+}
+
+template <class Generator, class U>
+inline typename Generator::result_type
+unwind_ptr_type(U* p, Generator* = 0)
+{
+    typedef typename cv_category<U>::type tag;
+    return unwind_type_cv<Generator>(p, tag());
+}
+
+template <bool is_ptr>
+struct unwind_helper
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U p, Generator* = 0)
+    {
+        return unwind_ptr_type(p, (Generator*)0);
+    }
+};
+
+template <>
+struct unwind_helper<false>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U& p, Generator* = 0)
+    {
+        return unwind_ptr_type(&p, (Generator*)0);
+    }
+};
+
+template <class Generator, class U>
+inline typename Generator::result_type
+
+unwind_type(U const& p, Generator*)
+
+
+
+{
+    return unwind_helper<is_pointer<U>::value>::execute(p, (Generator*)0);
+}
+
+enum { direct_ = 0, pointer_ = 1, reference_ = 2, reference_to_pointer_ = 3 };
+template <int indirection> struct unwind_helper2;
+
+template <>
+struct unwind_helper2<direct_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type((U*)0, (Generator*)0);
+    }
+};
+
+template <>
+struct unwind_helper2<pointer_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U*(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type((U*)0, (Generator*)0);
+    }
+};
+
+template <>
+struct unwind_helper2<reference_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U&(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type((U*)0, (Generator*)0);
+    }
+};
+
+template <>
+struct unwind_helper2<reference_to_pointer_>
+{
+    template <class Generator, class U>
+    static typename Generator::result_type
+    execute(U&(*)(), Generator* = 0)
+    {
+        return unwind_ptr_type(U(0), (Generator*)0);
+    }
+};
+# 149 "/usr/include/boost-1_42/boost/python/detail/unwind_type.hpp"
+template <class Generator, class U>
+inline typename Generator::result_type
+
+unwind_type(boost::type<U>*, Generator*)
+
+
+
+{
+    static const int indirection = (boost::is_pointer<U>::value ? pointer_ : 0) + (indirect_traits::is_reference_to_pointer<U>::value ? reference_to_pointer_ : boost::is_reference<U>::value ? reference_ : 0)
+
+
+
+
+
+                                  ;
+
+    return unwind_helper2<indirection>::execute((U(*)())0,(Generator*)0);
+}
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/converter/pytype_function.hpp" 2
+
+
+namespace boost { namespace python {
+
+namespace converter
+{
+template <PyTypeObject const* python_type>
+struct wrap_pytype
+{
+    static PyTypeObject const* get_pytype()
+    {
+        return python_type;
+    }
+};
+
+typedef PyTypeObject const* (*pytype_function)();
+
+
+
+
+
+namespace detail
+{
+struct unwind_type_id_helper{
+    typedef python::type_info result_type;
+    template <class U>
+    static result_type execute(U* ){
+        return python::type_id<U>();
+    }
+};
+
+template <class T>
+inline python::type_info unwind_type_id_(boost::type<T>* = 0, mpl::false_ * =0)
+{
+    return boost::python::detail::unwind_type<unwind_type_id_helper, T> ();
+}
+
+inline python::type_info unwind_type_id_(boost::type<void>* = 0, mpl::true_* =0)
+{
+    return type_id<void>();
+}
+
+template <class T>
+inline python::type_info unwind_type_id(boost::type<T>* p= 0)
+{
+    return unwind_type_id_(p, (mpl::bool_<boost::is_void<T>::value >*)0 );
+}
+}
+
+
+template <class T>
+struct expected_pytype_for_arg
+{
+    static PyTypeObject const *get_pytype()
+    {
+        const converter::registration *r=converter::registry::query(
+            detail::unwind_type_id_((boost::type<T>*)0, (mpl::bool_<boost::is_void<T>::value >*)0 )
+            );
+        return r ? r->expected_from_python_type(): 0;
+    }
+};
+
+
+template <class T>
+struct registered_pytype
+{
+    static PyTypeObject const *get_pytype()
+    {
+        const converter::registration *r=converter::registry::query(
+            detail::unwind_type_id_((boost::type<T>*) 0, (mpl::bool_<boost::is_void<T>::value >*)0 )
+            );
+        return r ? r->m_class_object: 0;
+    }
+};
+
+
+template <class T>
+struct registered_pytype_direct
+{
+    static PyTypeObject const* get_pytype()
+    {
+        return registered<T>::converters.m_class_object;
+    }
+};
+
+template <class T>
+struct expected_from_python_type : expected_pytype_for_arg<T>{};
+
+template <class T>
+struct expected_from_python_type_direct
+{
+    static PyTypeObject const* get_pytype()
+    {
+        return registered<T>::converters.expected_from_python_type();
+    }
+};
+
+template <class T>
+struct to_python_target_type
+{
+    static PyTypeObject const *get_pytype()
+    {
+        const converter::registration *r=converter::registry::query(
+            detail::unwind_type_id_((boost::type<T>*)0, (mpl::bool_<boost::is_void<T>::value >*)0 )
+            );
+        return r ? r->to_python_target_type(): 0;
+    }
+};
+
+template <class T>
+struct to_python_target_type_direct
+{
+    static PyTypeObject const *get_pytype()
+    {
+        return registered<T>::converters.to_python_target_type();
+    }
+};
+
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/python/to_python_indirect.hpp"
+namespace boost { namespace python {
+
+template <class T, class MakeHolder>
+struct to_python_indirect
+{
+    template <class U>
+    inline PyObject*
+    operator()(U const& ref) const
+    {
+        return this->execute(const_cast<U&>(ref), is_pointer<U>());
+    }
+
+    inline PyTypeObject const*
+    get_pytype()const
+    {
+        return converter::registered_pytype<T>::get_pytype();
+    }
+
+ private:
+    template <class U>
+    inline PyObject* execute(U* ptr, mpl::true_) const
+    {
+
+        if (ptr == 0)
+            return python::detail::none();
+        else
+            return this->execute(*ptr, mpl::false_());
+    }
+
+    template <class U>
+    inline PyObject* execute(U const& x, mpl::false_) const
+    {
+        U* const p = &const_cast<U&>(x);
+        if (is_polymorphic<U>::value)
+        {
+            if (PyObject* o = detail::wrapper_base_::owner(p))
+                return incref(o);
+        }
+        return MakeHolder::execute(p);
+    }
+};
+
+
+
+
+namespace detail
+{
+  struct make_owning_holder
+  {
+      template <class T>
+      static PyObject* execute(T* p)
+      {
+
+
+
+
+
+
+          typedef std::auto_ptr<T> smart_pointer;
+
+          typedef objects::pointer_holder<smart_pointer, T> holder_t;
+
+          smart_pointer ptr(const_cast<T*>(p));
+          return objects::make_ptr_instance<T, holder_t>::execute(ptr);
+      }
+  };
+
+  struct make_reference_holder
+  {
+      template <class T>
+      static PyObject* execute(T* p)
+      {
+          typedef objects::pointer_holder<T*, T> holder_t;
+          T* q = const_cast<T*>(p);
+          return objects::make_ptr_instance<T, holder_t>::execute(q);
+      }
+  };
+}
+
+}}
+# 11 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/registered_pointee.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/pointer_type_id.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/converter/pointer_type_id.hpp"
+namespace boost { namespace python { namespace converter {
+
+namespace detail
+{
+  template <bool is_ref = false>
+  struct pointer_typeid_select
+  {
+      template <class T>
+      static inline type_info execute(T*(*)() = 0)
+      {
+          return type_id<T>();
+      }
+  };
+
+  template <>
+  struct pointer_typeid_select<true>
+  {
+      template <class T>
+      static inline type_info execute(T* const volatile&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+
+      template <class T>
+      static inline type_info execute(T*volatile&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+
+      template <class T>
+      static inline type_info execute(T*const&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+
+      template <class T>
+      static inline type_info execute(T*&(*)() = 0)
+      {
+          return type_id<T>();
+      }
+  };
+}
+
+
+
+
+
+template <class T>
+type_info pointer_type_id(T(*)() = 0)
+{
+    return detail::pointer_typeid_select<
+          is_reference<T>::value
+        >::execute((T(*)())0);
+}
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/converter/registered_pointee.hpp" 2
+
+
+
+
+namespace boost { namespace python { namespace converter {
+
+struct registration;
+
+
+template <class T>
+struct registered_pointee
+    : registered<
+        typename remove_pointer<
+           typename remove_cv<
+              typename remove_reference<T>::type
+           >::type
+        >::type
+    >
+{
+};
+# 60 "/usr/include/boost-1_42/boost/python/converter/registered_pointee.hpp"
+}}}
+# 14 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/converter/arg_to_python_base.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/converter/arg_to_python_base.hpp"
+namespace boost { namespace python { namespace converter {
+
+struct registration;
+
+namespace detail
+{
+  struct arg_to_python_base
+
+      : handle<>
+
+  {
+      arg_to_python_base(void const volatile* source, registration const&);
+
+
+
+
+
+
+  };
+}
+
+}}}
+# 15 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_deleter.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace converter {
+
+struct shared_ptr_deleter
+{
+    shared_ptr_deleter(handle<> owner);
+    ~shared_ptr_deleter();
+
+    void operator()(void const*);
+
+    handle<> owner;
+};
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/shared_ptr.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/shared_ptr.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 1
+# 29 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+# 1 "/usr/include/boost-1_42/boost/assert.hpp" 1
+# 36 "/usr/include/boost-1_42/boost/assert.hpp"
+# 1 "/usr/include/assert.h" 1 3 4
+# 37 "/usr/include/boost-1_42/boost/assert.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/bad_weak_ptr.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/smart_ptr/bad_weak_ptr.hpp"
+namespace boost
+{
+# 39 "/usr/include/boost-1_42/boost/smart_ptr/bad_weak_ptr.hpp"
+class bad_weak_ptr: public std::exception
+{
+public:
+
+    virtual char const * what() const throw()
+    {
+        return "tr1::bad_weak_ptr";
+    }
+};
+
+
+
+
+
+}
+# 29 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_has_sync.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp" 1
+# 29 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp"
+namespace boost
+{
+
+namespace detail
+{
+
+inline int atomic_exchange_and_add( int * pw, int dv )
+{
+
+
+
+
+    int r;
+
+    __asm__ __volatile__
+    (
+        "lock\n\t"
+        "xadd %1, %0":
+        "=m"( *pw ), "=r"( r ):
+        "m"( *pw ), "1"( dv ):
+        "memory", "cc"
+    );
+
+    return r;
+}
+
+inline void atomic_increment( int * pw )
+{
+
+
+    __asm__
+    (
+        "lock\n\t"
+        "incl %0":
+        "=m"( *pw ):
+        "m"( *pw ):
+        "cc"
+    );
+}
+
+inline int atomic_conditional_increment( int * pw )
+{
+
+
+
+
+    int rv, tmp;
+
+    __asm__
+    (
+        "movl %0, %%eax\n\t"
+        "0:\n\t"
+        "test %%eax, %%eax\n\t"
+        "je 1f\n\t"
+        "movl %%eax, %2\n\t"
+        "incl %2\n\t"
+        "lock\n\t"
+        "cmpxchgl %2, %0\n\t"
+        "jne 0b\n\t"
+        "1:":
+        "=m"( *pw ), "=&a"( rv ), "=&r"( tmp ):
+        "m"( *pw ):
+        "cc"
+    );
+
+    return rv;
+}
+
+class sp_counted_base
+{
+private:
+
+    sp_counted_base( sp_counted_base const & );
+    sp_counted_base & operator= ( sp_counted_base const & );
+
+    int use_count_;
+    int weak_count_;
+
+public:
+
+    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
+    {
+    }
+
+    virtual ~sp_counted_base()
+    {
+    }
+
+
+
+
+    virtual void dispose() = 0;
+
+
+
+    virtual void destroy()
+    {
+        delete this;
+    }
+
+    virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+
+    void add_ref_copy()
+    {
+        atomic_increment( &use_count_ );
+    }
+
+    bool add_ref_lock()
+    {
+        return atomic_conditional_increment( &use_count_ ) != 0;
+    }
+
+    void release()
+    {
+        if( atomic_exchange_and_add( &use_count_, -1 ) == 1 )
+        {
+            dispose();
+            weak_release();
+        }
+    }
+
+    void weak_add_ref()
+    {
+        atomic_increment( &weak_count_ );
+    }
+
+    void weak_release()
+    {
+        if( atomic_exchange_and_add( &weak_count_, -1 ) == 1 )
+        {
+            destroy();
+        }
+    }
+
+    long use_count() const
+    {
+        return static_cast<int const volatile &>( use_count_ );
+    }
+};
+
+}
+
+}
+# 37 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_base.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp" 1
+# 38 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 39 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp" 2
+
+namespace boost
+{
+# 50 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
+namespace detail
+{
+
+template<class X> class sp_counted_impl_p: public sp_counted_base
+{
+private:
+
+    X * px_;
+
+    sp_counted_impl_p( sp_counted_impl_p const & );
+    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );
+
+    typedef sp_counted_impl_p<X> this_type;
+
+public:
+
+    explicit sp_counted_impl_p( X * px ): px_( px )
+    {
+
+
+
+    }
+
+    virtual void dispose()
+    {
+
+
+
+        boost::checked_delete( px_ );
+    }
+
+    virtual void * get_deleter( detail::sp_typeinfo const & )
+    {
+        return 0;
+    }
+# 113 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
+};
+# 122 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
+template<class P, class D> class sp_counted_impl_pd: public sp_counted_base
+{
+private:
+
+    P ptr;
+    D del;
+
+    sp_counted_impl_pd( sp_counted_impl_pd const & );
+    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );
+
+    typedef sp_counted_impl_pd<P, D> this_type;
+
+public:
+
+
+
+    sp_counted_impl_pd( P p, D d ): ptr(p), del(d)
+    {
+    }
+
+    virtual void dispose()
+    {
+        del( ptr );
+    }
+
+    virtual void * get_deleter( detail::sp_typeinfo const & ti )
+    {
+        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
+    }
+# 179 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_counted_impl.hpp"
+};
+
+template<class P, class D, class A> class sp_counted_impl_pda: public sp_counted_base
+{
+private:
+
+    P p_;
+    D d_;
+    A a_;
+
+    sp_counted_impl_pda( sp_counted_impl_pda const & );
+    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );
+
+    typedef sp_counted_impl_pda<P, D, A> this_type;
+
+public:
+
+
+
+    sp_counted_impl_pda( P p, D d, A a ): p_( p ), d_( d ), a_( a )
+    {
+    }
+
+    virtual void dispose()
+    {
+        d_( p_ );
+    }
+
+    virtual void destroy()
+    {
+        typedef typename A::template rebind< this_type >::other A2;
+
+        A2 a2( a_ );
+
+        this->~this_type();
+        a2.deallocate( this, 1 );
+    }
+
+    virtual void * get_deleter( detail::sp_typeinfo const & ti )
+    {
+        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
+    }
+};
+
+
+
+
+
+}
+
+}
+# 31 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp" 2
+# 40 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+namespace boost
+{
+
+namespace detail
+{
+# 53 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+struct sp_nothrow_tag {};
+
+class weak_count;
+
+class shared_count
+{
+private:
+
+    sp_counted_base * pi_;
+
+
+
+
+
+    friend class weak_count;
+
+public:
+
+    shared_count(): pi_(0)
+
+
+
+    {
+    }
+
+    template<class Y> explicit shared_count( Y * p ): pi_( 0 )
+
+
+
+    {
+
+
+        try
+        {
+            pi_ = new sp_counted_impl_p<Y>( p );
+        }
+        catch(...)
+        {
+            boost::checked_delete( p );
+            throw;
+        }
+# 106 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+    }
+
+
+
+
+    template<class P, class D> shared_count( P p, D d ): pi_(0)
+
+
+
+
+    {
+
+
+
+
+
+        try
+        {
+            pi_ = new sp_counted_impl_pd<P, D>(p, d);
+        }
+        catch(...)
+        {
+            d(p);
+            throw;
+        }
+# 143 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+    }
+
+    template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )
+
+
+
+    {
+        typedef sp_counted_impl_pda<P, D, A> impl_type;
+        typedef typename A::template rebind< impl_type >::other A2;
+
+        A2 a2( a );
+
+
+
+        try
+        {
+            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
+        }
+        catch(...)
+        {
+            d( p );
+
+            if( pi_ != 0 )
+            {
+                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
+            }
+
+            throw;
+        }
+# 189 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+    }
+
+
+
+
+
+    template<class Y>
+    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )
+
+
+
+    {
+# 210 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+        r.release();
+    }
+
+
+
+    ~shared_count()
+    {
+        if( pi_ != 0 ) pi_->release();
+
+
+
+    }
+
+    shared_count(shared_count const & r): pi_(r.pi_)
+
+
+
+    {
+        if( pi_ != 0 ) pi_->add_ref_copy();
+    }
+# 243 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+    explicit shared_count(weak_count const & r);
+    shared_count( weak_count const & r, sp_nothrow_tag );
+
+    shared_count & operator= (shared_count const & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
+            if( tmp != 0 ) tmp->add_ref_copy();
+            if( pi_ != 0 ) pi_->release();
+            pi_ = tmp;
+        }
+
+        return *this;
+    }
+
+    void swap(shared_count & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    bool unique() const
+    {
+        return use_count() == 1;
+    }
+
+    bool empty() const
+    {
+        return pi_ == 0;
+    }
+
+    friend inline bool operator==(shared_count const & a, shared_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(shared_count const & a, shared_count const & b)
+    {
+        return std::less<sp_counted_base *>()( a.pi_, b.pi_ );
+    }
+
+    void * get_deleter( sp_typeinfo const & ti ) const
+    {
+        return pi_? pi_->get_deleter( ti ): 0;
+    }
+};
+
+
+class weak_count
+{
+private:
+
+    sp_counted_base * pi_;
+
+
+
+
+
+    friend class shared_count;
+
+public:
+
+    weak_count(): pi_(0)
+
+
+
+    {
+    }
+
+    weak_count(shared_count const & r): pi_(r.pi_)
+
+
+
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+
+    weak_count(weak_count const & r): pi_(r.pi_)
+
+
+
+    {
+        if(pi_ != 0) pi_->weak_add_ref();
+    }
+# 350 "/usr/include/boost-1_42/boost/smart_ptr/detail/shared_count.hpp"
+    ~weak_count()
+    {
+        if(pi_ != 0) pi_->weak_release();
+
+
+
+    }
+
+    weak_count & operator= (shared_count const & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
+
+        return *this;
+    }
+
+    weak_count & operator= (weak_count const & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+
+        if( tmp != pi_ )
+        {
+            if(tmp != 0) tmp->weak_add_ref();
+            if(pi_ != 0) pi_->weak_release();
+            pi_ = tmp;
+        }
+
+        return *this;
+    }
+
+    void swap(weak_count & r)
+    {
+        sp_counted_base * tmp = r.pi_;
+        r.pi_ = pi_;
+        pi_ = tmp;
+    }
+
+    long use_count() const
+    {
+        return pi_ != 0? pi_->use_count(): 0;
+    }
+
+    bool empty() const
+    {
+        return pi_ == 0;
+    }
+
+    friend inline bool operator==(weak_count const & a, weak_count const & b)
+    {
+        return a.pi_ == b.pi_;
+    }
+
+    friend inline bool operator<(weak_count const & a, weak_count const & b)
+    {
+        return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+    }
+};
+
+inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
+
+
+
+{
+    if( pi_ == 0 || !pi_->add_ref_lock() )
+    {
+        boost::throw_exception( boost::bad_weak_ptr() );
+    }
+}
+
+inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
+
+
+
+{
+    if( pi_ != 0 && !pi_->add_ref_lock() )
+    {
+        pi_ = 0;
+    }
+}
+
+}
+
+}
+# 33 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_convertible.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/smart_ptr/detail/sp_convertible.hpp"
+namespace boost
+{
+
+namespace detail
+{
+
+template< class Y, class T > struct sp_convertible
+{
+    typedef char (&yes) [1];
+    typedef char (&no) [2];
+
+    static yes f( T* );
+    static no f( ... );
+
+    enum _vt { value = sizeof( f( static_cast<Y*>(0) ) ) == sizeof(yes) };
+};
+
+struct sp_empty
+{
+};
+
+template< bool > struct sp_enable_if_convertible_impl;
+
+template<> struct sp_enable_if_convertible_impl<true>
+{
+    typedef sp_empty type;
+};
+
+template<> struct sp_enable_if_convertible_impl<false>
+{
+};
+
+template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
+{
+};
+
+}
+
+}
+# 35 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock.hpp" 1
+# 38 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_sync.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_sync.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/yield_k.hpp" 1
+# 91 "/usr/include/boost-1_42/boost/smart_ptr/detail/yield_k.hpp"
+namespace boost
+{
+
+namespace detail
+{
+
+inline void yield( unsigned k )
+{
+    if( k < 4 )
+    {
+    }
+
+    else if( k < 16 )
+    {
+        __asm__ __volatile__( "rep; nop" : : : "memory" );
+    }
+
+    else if( k < 32 || k & 1 )
+    {
+        sched_yield();
+    }
+    else
+    {
+
+        struct timespec rqtp = { 0, 0 };
+
+
+
+
+        rqtp.tv_sec = 0;
+        rqtp.tv_nsec = 1000;
+
+        nanosleep( &rqtp, 0 );
+    }
+}
+
+}
+
+}
+# 19 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_sync.hpp" 2
+
+
+
+
+
+namespace boost
+{
+
+namespace detail
+{
+
+class spinlock
+{
+public:
+
+    int v_;
+
+public:
+
+    bool try_lock()
+    {
+        int r = __sync_lock_test_and_set( &v_, 1 );
+        return r == 0;
+    }
+
+    void lock()
+    {
+        for( unsigned k = 0; !try_lock(); ++k )
+        {
+            boost::detail::yield( k );
+        }
+    }
+
+    void unlock()
+    {
+        __sync_lock_release( &v_ );
+    }
+
+public:
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( spinlock & sp ): sp_( sp )
+        {
+            sp.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+}
+}
+# 39 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 27 "/usr/include/boost-1_42/boost/smart_ptr/detail/spinlock_pool.hpp" 2
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< int I > class spinlock_pool
+{
+private:
+
+    static spinlock pool_[ 41 ];
+
+public:
+
+    static spinlock & spinlock_for( void const * pv )
+    {
+        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;
+        return pool_[ i ];
+    }
+
+    class scoped_lock
+    {
+    private:
+
+        spinlock & sp_;
+
+        scoped_lock( scoped_lock const & );
+        scoped_lock & operator=( scoped_lock const & );
+
+    public:
+
+        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
+        {
+            sp_.lock();
+        }
+
+        ~scoped_lock()
+        {
+            sp_.unlock();
+        }
+    };
+};
+
+template< int I > spinlock spinlock_pool< I >::pool_[ 41 ] =
+{
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}, {0}, {0}, {0}, {0},
+    {0}
+};
+
+}
+}
+# 38 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/memory_order.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/memory_order.hpp"
+namespace boost
+{
+# 41 "/usr/include/boost-1_42/boost/memory_order.hpp"
+enum memory_order
+{
+    memory_order_relaxed = 0,
+    memory_order_acquire = 1,
+    memory_order_release = 2,
+    memory_order_acq_rel = 3,
+    memory_order_seq_cst = 7,
+    memory_order_consume = 8
+};
+
+}
+# 39 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
+# 58 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+namespace boost
+{
+
+template<class T> class shared_ptr;
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+template<class T> class enable_shared_from_this2;
+
+namespace detail
+{
+
+struct static_cast_tag {};
+struct const_cast_tag {};
+struct dynamic_cast_tag {};
+struct polymorphic_cast_tag {};
+
+template<class T> struct shared_ptr_traits
+{
+    typedef T & reference;
+};
+
+template<> struct shared_ptr_traits<void>
+{
+    typedef void reference;
+};
+
+
+
+template<> struct shared_ptr_traits<void const>
+{
+    typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void volatile>
+{
+    typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void const volatile>
+{
+    typedef void reference;
+};
+
+
+
+
+
+template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
+{
+    if( pe != 0 )
+    {
+        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
+    }
+}
+
+template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_this2< T > const * pe )
+{
+    if( pe != 0 )
+    {
+        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
+    }
+}
+# 136 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+inline void sp_enable_shared_from_this( ... )
+{
+}
+
+
+
+
+
+
+
+template< class T, class R > struct sp_enable_if_auto_ptr
+{
+};
+
+template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
+{
+    typedef R type;
+};
+
+
+
+}
+# 168 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+template<class T> class shared_ptr
+{
+private:
+
+
+    typedef shared_ptr<T> this_type;
+
+public:
+
+    typedef T element_type;
+    typedef T value_type;
+    typedef T * pointer;
+    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;
+
+    shared_ptr(): px(0), pn()
+    {
+    }
+
+    template<class Y>
+    explicit shared_ptr( Y * p ): px( p ), pn( p )
+    {
+        boost::detail::sp_enable_shared_from_this( this, p, p );
+    }
+
+
+
+
+
+
+
+    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
+    {
+        boost::detail::sp_enable_shared_from_this( this, p, p );
+    }
+
+
+
+    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
+    {
+        boost::detail::sp_enable_shared_from_this( this, p, p );
+    }
+
+
+
+    template<class Y>
+    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn)
+    {
+
+        px = r.px;
+    }
+
+    template<class Y>
+    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
+    {
+        if( !pn.empty() )
+        {
+            px = r.px;
+        }
+    }
+
+    template<class Y>
+
+
+    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )
+
+
+
+
+
+
+    : px( r.px ), pn( r.pn )
+    {
+    }
+
+
+    template< class Y >
+    shared_ptr( shared_ptr<Y> const & r, T * p ): px( p ), pn( r.pn )
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
+    {
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0)
+        {
+            pn = boost::detail::shared_count();
+        }
+    }
+
+    template<class Y>
+    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+    {
+        if(px == 0)
+        {
+            boost::throw_exception(std::bad_cast());
+        }
+    }
+
+
+
+    template<class Y>
+    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
+    {
+        Y * tmp = r.get();
+        pn = boost::detail::shared_count(r);
+        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
+    }
+
+
+
+    template<class Ap>
+    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
+    {
+        typename Ap::element_type * tmp = r.get();
+        pn = boost::detail::shared_count( r );
+        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
+    }
+# 303 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+    shared_ptr & operator=( shared_ptr const & r )
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+
+
+    template<class Y>
+    shared_ptr & operator=(shared_ptr<Y> const & r)
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+
+
+
+
+    template<class Y>
+    shared_ptr & operator=( std::auto_ptr<Y> & r )
+    {
+        this_type(r).swap(*this);
+        return *this;
+    }
+
+
+
+    template<class Ap>
+    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
+    {
+        this_type( r ).swap( *this );
+        return *this;
+    }
+# 384 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+    void reset()
+    {
+        this_type().swap(*this);
+    }
+
+    template<class Y> void reset(Y * p)
+    {
+        (static_cast<void> (0));
+        this_type(p).swap(*this);
+    }
+
+    template<class Y, class D> void reset( Y * p, D d )
+    {
+        this_type( p, d ).swap( *this );
+    }
+
+    template<class Y, class D, class A> void reset( Y * p, D d, A a )
+    {
+        this_type( p, d, a ).swap( *this );
+    }
+
+    template<class Y> void reset( shared_ptr<Y> const & r, T * p )
+    {
+        this_type( r, p ).swap( *this );
+    }
+
+    reference operator* () const
+    {
+        (static_cast<void> (0));
+        return *px;
+    }
+
+    T * operator-> () const
+    {
+        (static_cast<void> (0));
+        return px;
+    }
+
+    T * get() const
+    {
+        return px;
+    }
+
+
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp" 1
+# 43 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp"
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const
+    {
+        return px == 0? 0: &this_type::px;
+    }
+
+
+
+
+    bool operator! () const
+    {
+        return px == 0;
+    }
+# 429 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp" 2
+
+    bool unique() const
+    {
+        return pn.unique();
+    }
+
+    long use_count() const
+    {
+        return pn.use_count();
+    }
+
+    void swap(shared_ptr<T> & other)
+    {
+        std::swap(px, other.px);
+        pn.swap(other.pn);
+    }
+
+    template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
+    {
+        return pn < rhs.pn;
+    }
+
+    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
+    {
+        return pn.get_deleter( ti );
+    }
+
+    bool _internal_equiv( shared_ptr const & r ) const
+    {
+        return px == r.px && pn == r.pn;
+    }
+
+
+
+
+
+
+private:
+
+    template<class Y> friend class shared_ptr;
+    template<class Y> friend class weak_ptr;
+
+
+
+
+    T * px;
+    boost::detail::shared_count pn;
+
+};
+
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a.get() != b.get();
+}
+# 500 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+    return a._internal_less(b);
+}
+
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+    a.swap(b);
+}
+
+template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::const_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
+}
+
+
+
+template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
+{
+    return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
+{
+    (static_cast<void> (0));
+    return shared_static_cast<T>(r);
+}
+
+
+
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+{
+    return p.get();
+}
+# 577 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+
+{
+    os << p.get();
+    return os;
+}
+# 607 "/usr/include/boost-1_42/boost/smart_ptr/shared_ptr.hpp"
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+    return static_cast<D *>(p._internal_get_deleter(typeid(D)));
+}
+
+
+
+
+
+
+
+template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * )
+{
+    return false;
+}
+
+template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    return *p;
+}
+
+template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order )
+{
+    return atomic_load( p );
+}
+
+template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
+{
+    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
+    p->swap( r );
+}
+
+template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
+{
+    atomic_store( p, r );
+}
+
+template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+
+    sp.lock();
+    p->swap( r );
+    sp.unlock();
+
+    return r;
+}
+
+template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order )
+{
+    return atomic_exchange( p, r );
+}
+
+template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
+{
+    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
+
+    sp.lock();
+
+    if( p->_internal_equiv( *v ) )
+    {
+        p->swap( w );
+
+        sp.unlock();
+
+        return true;
+    }
+    else
+    {
+        shared_ptr<T> tmp( *p );
+
+        sp.unlock();
+
+        tmp.swap( *v );
+        return false;
+    }
+}
+
+template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order , memory_order )
+{
+    return atomic_compare_exchange( p, v, w );
+}
+
+
+
+}
+# 18 "/usr/include/boost-1_42/boost/shared_ptr.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_to_python.hpp" 2
+
+
+namespace boost { namespace python { namespace converter {
+
+template <class T>
+PyObject* shared_ptr_to_python(shared_ptr<T> const& x)
+{
+    if (!x)
+        return python::detail::none();
+    else if (shared_ptr_deleter* d = boost::get_deleter<shared_ptr_deleter>(x))
+        return incref( get_pointer( d->owner ) );
+    else
+        return converter::registered<shared_ptr<T> const&>::converters.to_python(&x);
+}
+
+}}}
+# 16 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/ssize_t.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/ssize_t.hpp"
+namespace boost { namespace python {
+
+
+
+typedef Py_ssize_t ssize_t;
+ssize_t const ssize_t_max = ((Py_ssize_t)(((size_t)-1)>>1));
+ssize_t const ssize_t_min = (-((Py_ssize_t)(((size_t)-1)>>1))-1);
+# 27 "/usr/include/boost-1_42/boost/python/ssize_t.hpp"
+}}
+# 11 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/implicit_cast.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/identity.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/identity.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename T = na
+    >
+struct identity
+{
+    typedef T type;
+   
+};
+
+template<
+      typename T = na
+    >
+struct make_identity
+{
+    typedef identity<T> type;
+   
+};
+
+template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
+template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }
+
+}}
+# 9 "/usr/include/boost-1_42/boost/implicit_cast.hpp" 2
+
+namespace boost {
+
+
+
+
+
+
+template <typename T>
+inline T implicit_cast (typename mpl::identity<T>::type x) {
+    return x;
+}
+
+
+
+
+
+}
+# 12 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 2
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
+# 77 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+
+  template<typename _Tp>
+    _Tp __cmath_power(_Tp, unsigned int);
+
+  template<typename _Tp>
+    inline _Tp
+    __pow_helper(_Tp __x, int __n)
+    {
+      return __n < 0
+        ? _Tp(1)/__cmath_power(__x, -__n)
+        : __cmath_power(__x, __n);
+    }
+
+  inline double
+  abs(double __x)
+  { return __builtin_fabs(__x); }
+
+  inline float
+  abs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline long double
+  abs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    abs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::acos;
+
+  inline float
+  acos(float __x)
+  { return __builtin_acosf(__x); }
+
+  inline long double
+  acos(long double __x)
+  { return __builtin_acosl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    acos(_Tp __x)
+    { return __builtin_acos(__x); }
+
+  using ::asin;
+
+  inline float
+  asin(float __x)
+  { return __builtin_asinf(__x); }
+
+  inline long double
+  asin(long double __x)
+  { return __builtin_asinl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    asin(_Tp __x)
+    { return __builtin_asin(__x); }
+
+  using ::atan;
+
+  inline float
+  atan(float __x)
+  { return __builtin_atanf(__x); }
+
+  inline long double
+  atan(long double __x)
+  { return __builtin_atanl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    atan(_Tp __x)
+    { return __builtin_atan(__x); }
+
+  using ::atan2;
+
+  inline float
+  atan2(float __y, float __x)
+  { return __builtin_atan2f(__y, __x); }
+
+  inline long double
+  atan2(long double __y, long double __x)
+  { return __builtin_atan2l(__y, __x); }
+
+  template<typename _Tp, typename _Up>
+    inline
+    typename __gnu_cxx::__promote_2<
+    typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
+        && __is_arithmetic<_Up>::__value,
+        _Tp>::__type, _Up>::__type
+    atan2(_Tp __y, _Up __x)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return atan2(__type(__y), __type(__x));
+    }
+
+  using ::ceil;
+
+  inline float
+  ceil(float __x)
+  { return __builtin_ceilf(__x); }
+
+  inline long double
+  ceil(long double __x)
+  { return __builtin_ceill(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    ceil(_Tp __x)
+    { return __builtin_ceil(__x); }
+
+  using ::cos;
+
+  inline float
+  cos(float __x)
+  { return __builtin_cosf(__x); }
+
+  inline long double
+  cos(long double __x)
+  { return __builtin_cosl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    cos(_Tp __x)
+    { return __builtin_cos(__x); }
+
+  using ::cosh;
+
+  inline float
+  cosh(float __x)
+  { return __builtin_coshf(__x); }
+
+  inline long double
+  cosh(long double __x)
+  { return __builtin_coshl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    cosh(_Tp __x)
+    { return __builtin_cosh(__x); }
+
+  using ::exp;
+
+  inline float
+  exp(float __x)
+  { return __builtin_expf(__x); }
+
+  inline long double
+  exp(long double __x)
+  { return __builtin_expl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    exp(_Tp __x)
+    { return __builtin_exp(__x); }
+
+  using ::fabs;
+
+  inline float
+  fabs(float __x)
+  { return __builtin_fabsf(__x); }
+
+  inline long double
+  fabs(long double __x)
+  { return __builtin_fabsl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    fabs(_Tp __x)
+    { return __builtin_fabs(__x); }
+
+  using ::floor;
+
+  inline float
+  floor(float __x)
+  { return __builtin_floorf(__x); }
+
+  inline long double
+  floor(long double __x)
+  { return __builtin_floorl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    floor(_Tp __x)
+    { return __builtin_floor(__x); }
+
+  using ::fmod;
+
+  inline float
+  fmod(float __x, float __y)
+  { return __builtin_fmodf(__x, __y); }
+
+  inline long double
+  fmod(long double __x, long double __y)
+  { return __builtin_fmodl(__x, __y); }
+
+  using ::frexp;
+
+  inline float
+  frexp(float __x, int* __exp)
+  { return __builtin_frexpf(__x, __exp); }
+
+  inline long double
+  frexp(long double __x, int* __exp)
+  { return __builtin_frexpl(__x, __exp); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    frexp(_Tp __x, int* __exp)
+    { return __builtin_frexp(__x, __exp); }
+
+  using ::ldexp;
+
+  inline float
+  ldexp(float __x, int __exp)
+  { return __builtin_ldexpf(__x, __exp); }
+
+  inline long double
+  ldexp(long double __x, int __exp)
+  { return __builtin_ldexpl(__x, __exp); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+  ldexp(_Tp __x, int __exp)
+  { return __builtin_ldexp(__x, __exp); }
+
+  using ::log;
+
+  inline float
+  log(float __x)
+  { return __builtin_logf(__x); }
+
+  inline long double
+  log(long double __x)
+  { return __builtin_logl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    log(_Tp __x)
+    { return __builtin_log(__x); }
+
+  using ::log10;
+
+  inline float
+  log10(float __x)
+  { return __builtin_log10f(__x); }
+
+  inline long double
+  log10(long double __x)
+  { return __builtin_log10l(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    log10(_Tp __x)
+    { return __builtin_log10(__x); }
+
+  using ::modf;
+
+  inline float
+  modf(float __x, float* __iptr)
+  { return __builtin_modff(__x, __iptr); }
+
+  inline long double
+  modf(long double __x, long double* __iptr)
+  { return __builtin_modfl(__x, __iptr); }
+
+  using ::pow;
+
+  inline float
+  pow(float __x, float __y)
+  { return __builtin_powf(__x, __y); }
+
+  inline long double
+  pow(long double __x, long double __y)
+  { return __builtin_powl(__x, __y); }
+
+
+
+
+  inline double
+  pow(double __x, int __i)
+  { return __builtin_powi(__x, __i); }
+
+  inline float
+  pow(float __x, int __n)
+  { return __builtin_powif(__x, __n); }
+
+  inline long double
+  pow(long double __x, int __n)
+  { return __builtin_powil(__x, __n); }
+
+
+  template<typename _Tp, typename _Up>
+    inline
+    typename __gnu_cxx::__promote_2<
+    typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
+        && __is_arithmetic<_Up>::__value,
+        _Tp>::__type, _Up>::__type
+    pow(_Tp __x, _Up __y)
+    {
+      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
+      return pow(__type(__x), __type(__y));
+    }
+
+  using ::sin;
+
+  inline float
+  sin(float __x)
+  { return __builtin_sinf(__x); }
+
+  inline long double
+  sin(long double __x)
+  { return __builtin_sinl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    sin(_Tp __x)
+    { return __builtin_sin(__x); }
+
+  using ::sinh;
+
+  inline float
+  sinh(float __x)
+  { return __builtin_sinhf(__x); }
+
+  inline long double
+  sinh(long double __x)
+  { return __builtin_sinhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    sinh(_Tp __x)
+    { return __builtin_sinh(__x); }
+
+  using ::sqrt;
+
+  inline float
+  sqrt(float __x)
+  { return __builtin_sqrtf(__x); }
+
+  inline long double
+  sqrt(long double __x)
+  { return __builtin_sqrtl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    sqrt(_Tp __x)
+    { return __builtin_sqrt(__x); }
+
+  using ::tan;
+
+  inline float
+  tan(float __x)
+  { return __builtin_tanf(__x); }
+
+  inline long double
+  tan(long double __x)
+  { return __builtin_tanl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    tan(_Tp __x)
+    { return __builtin_tan(__x); }
+
+  using ::tanh;
+
+  inline float
+  tanh(float __x)
+  { return __builtin_tanhf(__x); }
+
+  inline long double
+  tanh(long double __x)
+  { return __builtin_tanhl(__x); }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
+        double>::__type
+    tanh(_Tp __x)
+    { return __builtin_tanh(__x); }
+
+}
+# 498 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    fpclassify(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
+      FP_SUBNORMAL, FP_ZERO, __type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isfinite(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isfinite(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isinf(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isinf(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isnan(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnan(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isnormal(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isnormal(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    signbit(_Tp __f)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_signbit(__type(__f));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isgreaterequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isgreaterequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isless(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isless(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    islessequal(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessequal(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    islessgreater(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_islessgreater(__type(__f1), __type(__f2));
+    }
+
+  template<typename _Tp>
+    inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
+        int>::__type
+    isunordered(_Tp __f1, _Tp __f2)
+    {
+      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
+      return __builtin_isunordered(__type(__f1), __type(__f2));
+    }
+
+}
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cmath.tcc" 1 3
+# 35 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/cmath.tcc" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _Tp>
+    inline _Tp
+    __cmath_power(_Tp __x, unsigned int __n)
+    {
+      _Tp __y = __n % 2 ? __x : _Tp(1);
+
+      while (__n >>= 1)
+        {
+          __x = __x * __x;
+          if (__n % 2)
+            __y = __y * __x;
+        }
+
+      return __y;
+    }
+
+}
+# 616 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 2 3
+# 47 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+       
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 57 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
+      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
+      typedef typename __string_type::size_type __size_type;
+
+    protected:
+
+      ios_base::openmode _M_mode;
+
+
+      __string_type _M_string;
+
+    public:
+# 91 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_stringbuf(ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(__mode), _M_string()
+      { }
+# 104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_stringbuf(const __string_type& __str,
+        ios_base::openmode __mode = ios_base::in | ios_base::out)
+      : __streambuf_type(), _M_mode(), _M_string(__str.data(), __str.size())
+      { _M_stringbuf_init(__mode); }
+# 119 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      __string_type
+      str() const
+      {
+ __string_type __ret;
+ if (this->pptr())
+   {
+
+     if (this->pptr() > this->egptr())
+       __ret = __string_type(this->pbase(), this->pptr());
+     else
+        __ret = __string_type(this->pbase(), this->egptr());
+   }
+ else
+   __ret = _M_string;
+ return __ret;
+      }
+# 143 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      void
+      str(const __string_type& __s)
+      {
+
+ _M_string.assign(__s.data(), __s.size());
+ _M_stringbuf_init(_M_mode);
+      }
+
+    protected:
+
+      void
+      _M_stringbuf_init(ios_base::openmode __mode)
+      {
+ _M_mode = __mode;
+ __size_type __len = 0;
+ if (_M_mode & (ios_base::ate | ios_base::app))
+   __len = _M_string.size();
+ _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
+      }
+
+      virtual streamsize
+      showmanyc()
+      {
+ streamsize __ret = -1;
+ if (_M_mode & ios_base::in)
+   {
+     _M_update_egptr();
+     __ret = this->egptr() - this->gptr();
+   }
+ return __ret;
+      }
+
+      virtual int_type
+      underflow();
+
+      virtual int_type
+      pbackfail(int_type __c = traits_type::eof());
+
+      virtual int_type
+      overflow(int_type __c = traits_type::eof());
+# 195 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      virtual __streambuf_type*
+      setbuf(char_type* __s, streamsize __n)
+      {
+ if (__s && __n >= 0)
+   {
+
+
+
+
+
+
+     _M_string.clear();
+
+
+     _M_sync(__s, __n, 0);
+   }
+ return this;
+      }
+
+      virtual pos_type
+      seekoff(off_type __off, ios_base::seekdir __way,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+      virtual pos_type
+      seekpos(pos_type __sp,
+       ios_base::openmode __mode = ios_base::in | ios_base::out);
+
+
+
+
+      void
+      _M_sync(char_type* __base, __size_type __i, __size_type __o);
+
+
+
+      void
+      _M_update_egptr()
+      {
+ const bool __testin = _M_mode & ios_base::in;
+ if (this->pptr() && this->pptr() > this->egptr())
+   {
+     if (__testin)
+       this->setg(this->eback(), this->gptr(), this->pptr());
+     else
+       this->setg(this->pptr(), this->pptr(), this->pptr());
+   }
+      }
+    };
+# 255 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+  template<typename _CharT, typename _Traits, typename _Alloc>
+    class basic_istringstream : public basic_istream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_istream<char_type, traits_type> __istream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 291 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_istringstream(ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+# 309 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_istringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::in)
+      : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_istringstream()
+      { }
+# 331 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 365 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_ostream<char_type, traits_type> __ostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_ostringstream(ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+# 419 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_ostringstream(const __string_type& __str,
+     ios_base::openmode __mode = ios_base::out)
+      : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_ostringstream()
+      { }
+# 441 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+# 475 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+  template <typename _CharT, typename _Traits, typename _Alloc>
+    class basic_stringstream : public basic_iostream<_CharT, _Traits>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _Traits traits_type;
+
+
+      typedef _Alloc allocator_type;
+      typedef typename traits_type::int_type int_type;
+      typedef typename traits_type::pos_type pos_type;
+      typedef typename traits_type::off_type off_type;
+
+
+      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
+      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
+      typedef basic_iostream<char_type, traits_type> __iostream_type;
+
+    private:
+      __stringbuf_type _M_stringbuf;
+
+    public:
+# 509 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_stringstream(ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__m)
+      { this->init(&_M_stringbuf); }
+# 525 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      explicit
+      basic_stringstream(const __string_type& __str,
+    ios_base::openmode __m = ios_base::out | ios_base::in)
+      : __iostream_type(), _M_stringbuf(__str, __m)
+      { this->init(&_M_stringbuf); }
+
+
+
+
+
+
+
+      ~basic_stringstream()
+      { }
+# 547 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 3
+      __stringbuf_type*
+      rdbuf() const
+      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }
+
+
+
+
+
+      __string_type
+      str() const
+      { return _M_stringbuf.str(); }
+
+
+
+
+
+
+
+      void
+      str(const __string_type& __s)
+      { _M_stringbuf.str(__s); }
+    };
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 1 3
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 3
+       
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    pbackfail(int_type __c)
+    {
+      int_type __ret = traits_type::eof();
+      if (this->eback() < this->gptr())
+ {
+
+
+   const bool __testeof = traits_type::eq_int_type(__c, __ret);
+   if (!__testeof)
+     {
+       const bool __testeq = traits_type::eq(traits_type::
+          to_char_type(__c),
+          this->gptr()[-1]);
+       const bool __testout = this->_M_mode & ios_base::out;
+       if (__testeq || __testout)
+  {
+    this->gbump(-1);
+    if (!__testeq)
+      *this->gptr() = traits_type::to_char_type(__c);
+    __ret = __c;
+  }
+     }
+   else
+     {
+       this->gbump(-1);
+       __ret = traits_type::not_eof(__c);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    overflow(int_type __c)
+    {
+      const bool __testout = this->_M_mode & ios_base::out;
+      if (__builtin_expect(!__testout, false))
+ return traits_type::eof();
+
+      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
+      if (__builtin_expect(__testeof, false))
+ return traits_type::not_eof(__c);
+
+      const __size_type __capacity = _M_string.capacity();
+      const __size_type __max_size = _M_string.max_size();
+      const bool __testput = this->pptr() < this->epptr();
+      if (__builtin_expect(!__testput && __capacity == __max_size, false))
+ return traits_type::eof();
+
+
+
+      const char_type __conv = traits_type::to_char_type(__c);
+      if (!__testput)
+ {
+# 110 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/sstream.tcc" 3
+   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
+       __size_type(512));
+   const __size_type __len = std::min(__opt_len, __max_size);
+   __string_type __tmp;
+   __tmp.reserve(__len);
+   if (this->pbase())
+     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
+   __tmp.push_back(__conv);
+   _M_string.swap(__tmp);
+   _M_sync(const_cast<char_type*>(_M_string.data()),
+    this->gptr() - this->eback(), this->pptr() - this->pbase());
+ }
+      else
+ *this->pptr() = __conv;
+      this->pbump(1);
+      return __c;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    underflow()
+    {
+      int_type __ret = traits_type::eof();
+      const bool __testin = this->_M_mode & ios_base::in;
+      if (__testin)
+ {
+
+   _M_update_egptr();
+
+   if (this->gptr() < this->egptr())
+     __ret = traits_type::to_int_type(*this->gptr());
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+      const bool __testboth = __testin && __testout && __way != ios_base::cur;
+      __testin &= !(__mode & ios_base::out);
+      __testout &= !(__mode & ios_base::in);
+
+
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !__off) && (__testin || __testout || __testboth))
+ {
+   _M_update_egptr();
+
+   off_type __newoffi = __off;
+   off_type __newoffo = __newoffi;
+   if (__way == ios_base::cur)
+     {
+       __newoffi += this->gptr() - __beg;
+       __newoffo += this->pptr() - __beg;
+     }
+   else if (__way == ios_base::end)
+     __newoffo = __newoffi += this->egptr() - __beg;
+
+   if ((__testin || __testboth)
+       && __newoffi >= 0
+       && this->egptr() - __beg >= __newoffi)
+     {
+       this->gbump((__beg + __newoffi) - this->gptr());
+       __ret = pos_type(__newoffi);
+     }
+   if ((__testout || __testboth)
+       && __newoffo >= 0
+       && this->egptr() - __beg >= __newoffo)
+     {
+       this->pbump((__beg + __newoffo) - this->pptr());
+       __ret = pos_type(__newoffo);
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    seekpos(pos_type __sp, ios_base::openmode __mode)
+    {
+      pos_type __ret = pos_type(off_type(-1));
+      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
+      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
+
+      const char_type* __beg = __testin ? this->eback() : this->pbase();
+      if ((__beg || !off_type(__sp)) && (__testin || __testout))
+ {
+   _M_update_egptr();
+
+   const off_type __pos(__sp);
+   const bool __testpos = (0 <= __pos
+      && __pos <= this->egptr() - __beg);
+   if (__testpos)
+     {
+       if (__testin)
+  this->gbump((__beg + __pos) - this->gptr());
+       if (__testout)
+                this->pbump((__beg + __pos) - this->pptr());
+       __ret = __sp;
+     }
+ }
+      return __ret;
+    }
+
+  template <class _CharT, class _Traits, class _Alloc>
+    void
+    basic_stringbuf<_CharT, _Traits, _Alloc>::
+    _M_sync(char_type* __base, __size_type __i, __size_type __o)
+    {
+      const bool __testin = _M_mode & ios_base::in;
+      const bool __testout = _M_mode & ios_base::out;
+      char_type* __endg = __base + _M_string.size();
+      char_type* __endp = __base + _M_string.capacity();
+
+      if (__base != _M_string.data())
+ {
+
+   __endg += __i;
+   __i = 0;
+   __endp = __endg;
+ }
+
+      if (__testin)
+ this->setg(__base, __base + __i, __endg);
+      if (__testout)
+ {
+   this->setp(__base, __endp);
+   this->pbump(__o);
+
+
+
+   if (!__testin)
+     this->setg(__endg, __endg, __endg);
+ }
+    }
+
+
+
+
+
+  extern template class basic_stringbuf<char>;
+  extern template class basic_istringstream<char>;
+  extern template class basic_ostringstream<char>;
+  extern template class basic_stringstream<char>;
+
+
+  extern template class basic_stringbuf<wchar_t>;
+  extern template class basic_istringstream<wchar_t>;
+  extern template class basic_ostringstream<wchar_t>;
+  extern template class basic_stringstream<wchar_t>;
+
+
+
+}
+# 574 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/sstream" 2 3
+# 48 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp> class complex;
+  template<> class complex<float>;
+  template<> class complex<double>;
+  template<> class complex<long double>;
+
+
+  template<typename _Tp> _Tp abs(const complex<_Tp>&);
+
+  template<typename _Tp> _Tp arg(const complex<_Tp>&);
+
+  template<typename _Tp> _Tp norm(const complex<_Tp>&);
+
+
+  template<typename _Tp> complex<_Tp> conj(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);
+
+
+
+  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);
+
+
+
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);
+
+
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
+
+  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
+                                          const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
+
+  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
+# 121 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    struct complex
+    {
+
+      typedef _Tp value_type;
+
+
+
+      complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
+      : _M_real(__r), _M_imag(__i) { }
+
+
+
+
+      template<typename _Up>
+        complex(const complex<_Up>& __z)
+ : _M_real(__z.real()), _M_imag(__z.imag()) { }
+# 149 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+      _Tp& real()
+      { return _M_real; }
+
+
+      const _Tp& real() const
+      { return _M_real; }
+
+
+      _Tp& imag()
+      { return _M_imag; }
+
+
+      const _Tp& imag() const
+      { return _M_imag; }
+
+
+
+
+      void real(_Tp __val)
+      { _M_real = __val; }
+
+      void imag(_Tp __val)
+      { _M_imag = __val; }
+
+
+      complex<_Tp>& operator=(const _Tp&);
+
+
+
+      complex<_Tp>&
+      operator+=(const _Tp& __t)
+      {
+ _M_real += __t;
+ return *this;
+      }
+
+
+
+      complex<_Tp>&
+      operator-=(const _Tp& __t)
+      {
+ _M_real -= __t;
+ return *this;
+      }
+
+
+      complex<_Tp>& operator*=(const _Tp&);
+
+      complex<_Tp>& operator/=(const _Tp&);
+
+
+
+
+
+      template<typename _Up>
+        complex<_Tp>& operator=(const complex<_Up>&);
+
+      template<typename _Up>
+        complex<_Tp>& operator+=(const complex<_Up>&);
+
+      template<typename _Up>
+        complex<_Tp>& operator-=(const complex<_Up>&);
+
+      template<typename _Up>
+        complex<_Tp>& operator*=(const complex<_Up>&);
+
+      template<typename _Up>
+        complex<_Tp>& operator/=(const complex<_Up>&);
+
+      const complex& __rep() const
+      { return *this; }
+
+    private:
+      _Tp _M_real;
+      _Tp _M_imag;
+    };
+
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const _Tp& __t)
+    {
+     _M_real = __t;
+     _M_imag = _Tp();
+     return *this;
+    }
+
+
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const _Tp& __t)
+    {
+      _M_real *= __t;
+      _M_imag *= __t;
+      return *this;
+    }
+
+
+  template<typename _Tp>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const _Tp& __t)
+    {
+      _M_real /= __t;
+      _M_imag /= __t;
+      return *this;
+    }
+
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator=(const complex<_Up>& __z)
+    {
+      _M_real = __z.real();
+      _M_imag = __z.imag();
+      return *this;
+    }
+
+
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator+=(const complex<_Up>& __z)
+    {
+      _M_real += __z.real();
+      _M_imag += __z.imag();
+      return *this;
+    }
+
+
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator-=(const complex<_Up>& __z)
+    {
+      _M_real -= __z.real();
+      _M_imag -= __z.imag();
+      return *this;
+    }
+
+
+
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator*=(const complex<_Up>& __z)
+    {
+      const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
+      _M_imag = _M_real * __z.imag() + _M_imag * __z.real();
+      _M_real = __r;
+      return *this;
+    }
+
+
+
+  template<typename _Tp>
+    template<typename _Up>
+    complex<_Tp>&
+    complex<_Tp>::operator/=(const complex<_Up>& __z)
+    {
+      const _Tp __r = _M_real * __z.real() + _M_imag * __z.imag();
+      const _Tp __n = std::norm(__z);
+      _M_imag = (_M_imag * __z.real() - _M_real * __z.imag()) / __n;
+      _M_real = __r / __n;
+      return *this;
+    }
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r += __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r += __x;
+      return __r;
+    }
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r -= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r(__x, -__y.imag());
+      __r -= __y.real();
+      return __r;
+    }
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r *= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator*(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __y;
+      __r *= __x;
+      return __r;
+    }
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const complex<_Tp>& __x, const _Tp& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator/(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      complex<_Tp> __r = __x;
+      __r /= __y;
+      return __r;
+    }
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator+(const complex<_Tp>& __x)
+    { return __x; }
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    operator-(const complex<_Tp>& __x)
+    { return complex<_Tp>(-__x.real(), -__x.imag()); }
+
+
+
+  template<typename _Tp>
+    inline bool
+    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }
+
+  template<typename _Tp>
+    inline bool
+    operator==(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() == __y && __x.imag() == _Tp(); }
+
+  template<typename _Tp>
+    inline bool
+    operator==(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x == __y.real() && _Tp() == __y.imag(); }
+
+
+
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x.real() != __y.real() || __x.imag() != __y.imag(); }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const complex<_Tp>& __x, const _Tp& __y)
+    { return __x.real() != __y || __x.imag() != _Tp(); }
+
+  template<typename _Tp>
+    inline bool
+    operator!=(const _Tp& __x, const complex<_Tp>& __y)
+    { return __x != __y.real() || _Tp() != __y.imag(); }
+
+
+
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, complex<_Tp>& __x)
+    {
+      _Tp __re_x, __im_x;
+      _CharT __ch;
+      __is >> __ch;
+      if (__ch == '(')
+ {
+   __is >> __re_x >> __ch;
+   if (__ch == ',')
+     {
+       __is >> __im_x >> __ch;
+       if (__ch == ')')
+  __x = complex<_Tp>(__re_x, __im_x);
+       else
+  __is.setstate(ios_base::failbit);
+     }
+   else if (__ch == ')')
+     __x = __re_x;
+   else
+     __is.setstate(ios_base::failbit);
+ }
+      else
+ {
+   __is.putback(__ch);
+   __is >> __re_x;
+   __x = __re_x;
+ }
+      return __is;
+    }
+
+
+  template<typename _Tp, typename _CharT, class _Traits>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, const complex<_Tp>& __x)
+    {
+      basic_ostringstream<_CharT, _Traits> __s;
+      __s.flags(__os.flags());
+      __s.imbue(__os.getloc());
+      __s.precision(__os.precision());
+      __s << '(' << __x.real() << ',' << __x.imag() << ')';
+      return __os << __s.str();
+    }
+# 541 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    inline _Tp&
+    real(complex<_Tp>& __z)
+    { return __z.real(); }
+
+  template<typename _Tp>
+    inline const _Tp&
+    real(const complex<_Tp>& __z)
+    { return __z.real(); }
+
+  template<typename _Tp>
+    inline _Tp&
+    imag(complex<_Tp>& __z)
+    { return __z.imag(); }
+
+  template<typename _Tp>
+    inline const _Tp&
+    imag(const complex<_Tp>& __z)
+    { return __z.imag(); }
+
+
+
+  template<typename _Tp>
+    inline _Tp
+    __complex_abs(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+      const _Tp __s = std::max(abs(__x), abs(__y));
+      if (__s == _Tp())
+        return __s;
+      __x /= __s;
+      __y /= __s;
+      return __s * sqrt(__x * __x + __y * __y);
+    }
+
+
+  inline float
+  __complex_abs(__complex__ float __z) { return __builtin_cabsf(__z); }
+
+  inline double
+  __complex_abs(__complex__ double __z) { return __builtin_cabs(__z); }
+
+  inline long double
+  __complex_abs(const __complex__ long double& __z)
+  { return __builtin_cabsl(__z); }
+
+  template<typename _Tp>
+    inline _Tp
+    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
+# 599 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    inline _Tp
+    __complex_arg(const complex<_Tp>& __z)
+    { return atan2(__z.imag(), __z.real()); }
+
+
+  inline float
+  __complex_arg(__complex__ float __z) { return __builtin_cargf(__z); }
+
+  inline double
+  __complex_arg(__complex__ double __z) { return __builtin_carg(__z); }
+
+  inline long double
+  __complex_arg(const __complex__ long double& __z)
+  { return __builtin_cargl(__z); }
+
+  template<typename _Tp>
+    inline _Tp
+    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
+# 629 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<bool>
+    struct _Norm_helper
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          const _Tp __x = __z.real();
+          const _Tp __y = __z.imag();
+          return __x * __x + __y * __y;
+        }
+    };
+
+  template<>
+    struct _Norm_helper<true>
+    {
+      template<typename _Tp>
+        static inline _Tp _S_do_it(const complex<_Tp>& __z)
+        {
+          _Tp __res = std::abs(__z);
+          return __res * __res;
+        }
+    };
+
+  template<typename _Tp>
+    inline _Tp
+    norm(const complex<_Tp>& __z)
+    {
+      return _Norm_helper<__is_floating<_Tp>::__value
+ && !0>::_S_do_it(__z);
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    polar(const _Tp& __rho, const _Tp& __theta)
+    { return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta)); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    conj(const complex<_Tp>& __z)
+    { return complex<_Tp>(__z.real(), -__z.imag()); }
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cos(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cos(__x) * cosh(__y), -sin(__x) * sinh(__y));
+    }
+
+
+  inline __complex__ float
+  __complex_cos(__complex__ float __z) { return __builtin_ccosf(__z); }
+
+  inline __complex__ double
+  __complex_cos(__complex__ double __z) { return __builtin_ccos(__z); }
+
+  inline __complex__ long double
+  __complex_cos(const __complex__ long double& __z)
+  { return __builtin_ccosl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }
+
+
+
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_cosh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(cosh(__x) * cos(__y), sinh(__x) * sin(__y));
+    }
+
+
+  inline __complex__ float
+  __complex_cosh(__complex__ float __z) { return __builtin_ccoshf(__z); }
+
+  inline __complex__ double
+  __complex_cosh(__complex__ double __z) { return __builtin_ccosh(__z); }
+
+  inline __complex__ long double
+  __complex_cosh(const __complex__ long double& __z)
+  { return __builtin_ccoshl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }
+
+
+
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_exp(const complex<_Tp>& __z)
+    { return std::polar(exp(__z.real()), __z.imag()); }
+
+
+  inline __complex__ float
+  __complex_exp(__complex__ float __z) { return __builtin_cexpf(__z); }
+
+  inline __complex__ double
+  __complex_exp(__complex__ double __z) { return __builtin_cexp(__z); }
+
+  inline __complex__ long double
+  __complex_exp(const __complex__ long double& __z)
+  { return __builtin_cexpl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
+# 760 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_log(const complex<_Tp>& __z)
+    { return complex<_Tp>(log(std::abs(__z)), std::arg(__z)); }
+
+
+  inline __complex__ float
+  __complex_log(__complex__ float __z) { return __builtin_clogf(__z); }
+
+  inline __complex__ double
+  __complex_log(__complex__ double __z) { return __builtin_clog(__z); }
+
+  inline __complex__ long double
+  __complex_log(const __complex__ long double& __z)
+  { return __builtin_clogl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }
+
+
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    log10(const complex<_Tp>& __z)
+    { return std::log(__z) / log(_Tp(10.0)); }
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sin(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y));
+    }
+
+
+  inline __complex__ float
+  __complex_sin(__complex__ float __z) { return __builtin_csinf(__z); }
+
+  inline __complex__ double
+  __complex_sin(__complex__ double __z) { return __builtin_csin(__z); }
+
+  inline __complex__ long double
+  __complex_sin(const __complex__ long double& __z)
+  { return __builtin_csinl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }
+
+
+
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_sinh(const complex<_Tp>& __z)
+    {
+      const _Tp __x = __z.real();
+      const _Tp __y = __z.imag();
+      return complex<_Tp>(sinh(__x) * cos(__y), cosh(__x) * sin(__y));
+    }
+
+
+  inline __complex__ float
+  __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
+
+  inline __complex__ double
+  __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); }
+
+  inline __complex__ long double
+  __complex_sinh(const __complex__ long double& __z)
+  { return __builtin_csinhl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
+# 852 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    complex<_Tp>
+    __complex_sqrt(const complex<_Tp>& __z)
+    {
+      _Tp __x = __z.real();
+      _Tp __y = __z.imag();
+
+      if (__x == _Tp())
+        {
+          _Tp __t = sqrt(abs(__y) / 2);
+          return complex<_Tp>(__t, __y < _Tp() ? -__t : __t);
+        }
+      else
+        {
+          _Tp __t = sqrt(2 * (std::abs(__z) + abs(__x)));
+          _Tp __u = __t / 2;
+          return __x > _Tp()
+            ? complex<_Tp>(__u, __y / __t)
+            : complex<_Tp>(abs(__y) / __t, __y < _Tp() ? -__u : __u);
+        }
+    }
+
+
+  inline __complex__ float
+  __complex_sqrt(__complex__ float __z) { return __builtin_csqrtf(__z); }
+
+  inline __complex__ double
+  __complex_sqrt(__complex__ double __z) { return __builtin_csqrt(__z); }
+
+  inline __complex__ long double
+  __complex_sqrt(const __complex__ long double& __z)
+  { return __builtin_csqrtl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
+# 896 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tan(const complex<_Tp>& __z)
+    { return std::sin(__z) / std::cos(__z); }
+
+
+  inline __complex__ float
+  __complex_tan(__complex__ float __z) { return __builtin_ctanf(__z); }
+
+  inline __complex__ double
+  __complex_tan(__complex__ double __z) { return __builtin_ctan(__z); }
+
+  inline __complex__ long double
+  __complex_tan(const __complex__ long double& __z)
+  { return __builtin_ctanl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
+# 924 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_tanh(const complex<_Tp>& __z)
+    { return std::sinh(__z) / std::cosh(__z); }
+
+
+  inline __complex__ float
+  __complex_tanh(__complex__ float __z) { return __builtin_ctanhf(__z); }
+
+  inline __complex__ double
+  __complex_tanh(__complex__ double __z) { return __builtin_ctanh(__z); }
+
+  inline __complex__ long double
+  __complex_tanh(const __complex__ long double& __z)
+  { return __builtin_ctanhl(__z); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
+# 956 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __z, int __n)
+    { return std::__pow_helper(__z, __n); }
+
+
+  template<typename _Tp>
+    complex<_Tp>
+    pow(const complex<_Tp>& __x, const _Tp& __y)
+    {
+
+
+
+
+      if (__x.imag() == _Tp() && __x.real() > _Tp())
+        return pow(__x.real(), __y);
+
+      complex<_Tp> __t = std::log(__x);
+      return std::polar(exp(__y * __t.real()), __y * __t.imag());
+    }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    __complex_pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __x == _Tp() ? _Tp() : std::exp(__y * std::log(__x)); }
+
+
+  inline __complex__ float
+  __complex_pow(__complex__ float __x, __complex__ float __y)
+  { return __builtin_cpowf(__x, __y); }
+
+  inline __complex__ double
+  __complex_pow(__complex__ double __x, __complex__ double __y)
+  { return __builtin_cpow(__x, __y); }
+
+  inline __complex__ long double
+  __complex_pow(const __complex__ long double& __x,
+  const __complex__ long double& __y)
+  { return __builtin_cpowl(__x, __y); }
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
+    { return __complex_pow(__x.__rep(), __y.__rep()); }
+
+
+
+
+
+
+
+  template<typename _Tp>
+    inline complex<_Tp>
+    pow(const _Tp& __x, const complex<_Tp>& __y)
+    {
+      return __x > _Tp() ? std::polar(pow(__x, __y.real()),
+          __y.imag() * log(__x))
+                  : std::pow(complex<_Tp>(__x), __y);
+    }
+
+
+
+  template<>
+    struct complex<float>
+    {
+      typedef float value_type;
+      typedef __complex__ float _ComplexT;
+
+      complex(_ComplexT __z) : _M_value(__z) { }
+
+      complex(float __r = 0.0f, float __i = 0.0f)
+      {
+ __real__ _M_value = __r;
+ __imag__ _M_value = __i;
+      }
+
+      explicit complex(const complex<double>&);
+      explicit complex(const complex<long double>&);
+# 1044 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+      float& real()
+      { return __real__ _M_value; }
+
+      const float& real() const
+      { return __real__ _M_value; }
+
+      float& imag()
+      { return __imag__ _M_value; }
+
+      const float& imag() const
+      { return __imag__ _M_value; }
+
+
+
+
+      void real(float __val)
+      { __real__ _M_value = __val; }
+
+      void imag(float __val)
+      { __imag__ _M_value = __val; }
+
+      complex<float>&
+      operator=(float __f)
+      {
+ __real__ _M_value = __f;
+ __imag__ _M_value = 0.0f;
+ return *this;
+      }
+
+      complex<float>&
+      operator+=(float __f)
+      {
+ __real__ _M_value += __f;
+ return *this;
+      }
+
+      complex<float>&
+      operator-=(float __f)
+      {
+ __real__ _M_value -= __f;
+ return *this;
+      }
+
+      complex<float>&
+      operator*=(float __f)
+      {
+ _M_value *= __f;
+ return *this;
+      }
+
+      complex<float>&
+      operator/=(float __f)
+      {
+ _M_value /= __f;
+ return *this;
+      }
+
+
+
+
+
+      template<typename _Tp>
+        complex<float>&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<float>&
+        operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+
+      template<class _Tp>
+        complex<float>&
+        operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+
+      template<class _Tp>
+        complex<float>&
+        operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+
+      template<class _Tp>
+        complex<float>&
+        operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+
+      const _ComplexT& __rep() const { return _M_value; }
+
+    private:
+      _ComplexT _M_value;
+    };
+
+
+
+  template<>
+    struct complex<double>
+    {
+      typedef double value_type;
+      typedef __complex__ double _ComplexT;
+
+      complex(_ComplexT __z) : _M_value(__z) { }
+
+      complex(double __r = 0.0, double __i = 0.0)
+      {
+ __real__ _M_value = __r;
+ __imag__ _M_value = __i;
+      }
+
+      complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+
+      explicit complex(const complex<long double>&);
+# 1190 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+      double& real()
+      { return __real__ _M_value; }
+
+      const double& real() const
+      { return __real__ _M_value; }
+
+      double& imag()
+      { return __imag__ _M_value; }
+
+      const double& imag() const
+      { return __imag__ _M_value; }
+
+
+
+
+      void real(double __val)
+      { __real__ _M_value = __val; }
+
+      void imag(double __val)
+      { __imag__ _M_value = __val; }
+
+      complex<double>&
+      operator=(double __d)
+      {
+ __real__ _M_value = __d;
+ __imag__ _M_value = 0.0;
+ return *this;
+      }
+
+      complex<double>&
+      operator+=(double __d)
+      {
+ __real__ _M_value += __d;
+ return *this;
+      }
+
+      complex<double>&
+      operator-=(double __d)
+      {
+ __real__ _M_value -= __d;
+ return *this;
+      }
+
+      complex<double>&
+      operator*=(double __d)
+      {
+ _M_value *= __d;
+ return *this;
+      }
+
+      complex<double>&
+      operator/=(double __d)
+      {
+ _M_value /= __d;
+ return *this;
+      }
+
+
+
+
+      template<typename _Tp>
+        complex<double>&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<double>&
+        operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<double>&
+        operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<double>&
+        operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<double>&
+        operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+
+      const _ComplexT& __rep() const { return _M_value; }
+
+    private:
+      _ComplexT _M_value;
+    };
+
+
+
+  template<>
+    struct complex<long double>
+    {
+      typedef long double value_type;
+      typedef __complex__ long double _ComplexT;
+
+      complex(_ComplexT __z) : _M_value(__z) { }
+
+      complex(long double __r = 0.0L, long double __i = 0.0L)
+      {
+ __real__ _M_value = __r;
+ __imag__ _M_value = __i;
+      }
+
+      complex(const complex<float>& __z)
+      : _M_value(__z.__rep()) { }
+
+      complex(const complex<double>& __z)
+      : _M_value(__z.__rep()) { }
+# 1336 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/complex" 3
+      long double& real()
+      { return __real__ _M_value; }
+
+      const long double& real() const
+      { return __real__ _M_value; }
+
+      long double& imag()
+      { return __imag__ _M_value; }
+
+      const long double& imag() const
+      { return __imag__ _M_value; }
+
+
+
+
+      void real(long double __val)
+      { __real__ _M_value = __val; }
+
+      void imag(long double __val)
+      { __imag__ _M_value = __val; }
+
+      complex<long double>&
+      operator=(long double __r)
+      {
+ __real__ _M_value = __r;
+ __imag__ _M_value = 0.0L;
+ return *this;
+      }
+
+      complex<long double>&
+      operator+=(long double __r)
+      {
+ __real__ _M_value += __r;
+ return *this;
+      }
+
+      complex<long double>&
+      operator-=(long double __r)
+      {
+ __real__ _M_value -= __r;
+ return *this;
+      }
+
+      complex<long double>&
+      operator*=(long double __r)
+      {
+ _M_value *= __r;
+ return *this;
+      }
+
+      complex<long double>&
+      operator/=(long double __r)
+      {
+ _M_value /= __r;
+ return *this;
+      }
+
+
+
+
+      template<typename _Tp>
+        complex<long double>&
+        operator=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value = __z.real();
+   __imag__ _M_value = __z.imag();
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<long double>&
+ operator+=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value += __z.real();
+   __imag__ _M_value += __z.imag();
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<long double>&
+ operator-=(const complex<_Tp>& __z)
+ {
+   __real__ _M_value -= __z.real();
+   __imag__ _M_value -= __z.imag();
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<long double>&
+ operator*=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value *= __t;
+   return *this;
+ }
+
+      template<typename _Tp>
+        complex<long double>&
+ operator/=(const complex<_Tp>& __z)
+ {
+   _ComplexT __t;
+   __real__ __t = __z.real();
+   __imag__ __t = __z.imag();
+   _M_value /= __t;
+   return *this;
+ }
+
+      const _ComplexT& __rep() const { return _M_value; }
+
+    private:
+      _ComplexT _M_value;
+    };
+
+
+
+  inline
+  complex<float>::complex(const complex<double>& __z)
+  : _M_value(__z.__rep()) { }
+
+  inline
+  complex<float>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+
+  inline
+  complex<double>::complex(const complex<long double>& __z)
+  : _M_value(__z.__rep()) { }
+
+
+
+
+
+  extern template istream& operator>>(istream&, complex<float>&);
+  extern template ostream& operator<<(ostream&, const complex<float>&);
+  extern template istream& operator>>(istream&, complex<double>&);
+  extern template ostream& operator<<(ostream&, const complex<double>&);
+  extern template istream& operator>>(istream&, complex<long double>&);
+  extern template ostream& operator<<(ostream&, const complex<long double>&);
+
+
+  extern template wistream& operator>>(wistream&, complex<float>&);
+  extern template wostream& operator<<(wostream&, const complex<float>&);
+  extern template wistream& operator>>(wistream&, complex<double>&);
+  extern template wostream& operator<<(wostream&, const complex<double>&);
+  extern template wistream& operator>>(wistream&, complex<long double>&);
+  extern template wostream& operator<<(wostream&, const complex<long double>&);
+
+
+
+
+
+}
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, _Up>
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2<_Tp, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+  template<typename _Tp, typename _Up>
+    struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
+    {
+    public:
+      typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
+    };
+
+}
+# 14 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
+namespace boost { namespace python {
+
+namespace converter
+{
+  template <class T> struct arg_to_python;
+  PyObject* do_return_to_python(char);
+  PyObject* do_return_to_python(char const*);
+  PyObject* do_return_to_python(PyObject*);
+  PyObject* do_arg_to_python(PyObject*);
+}
+
+
+template <class T> struct to_python_value;
+
+namespace detail
+{
+
+
+  struct builtin_to_python
+  {
+
+
+
+      static const bool uses_registry = false;
+  };
+}
+# 113 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
+template <> struct to_python_value<bool&> : detail::builtin_to_python { inline PyObject* operator()(bool const& x) const { return (::PyBool_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyBool_Type); } }; template <> struct to_python_value<bool const&> : detail::builtin_to_python { inline PyObject* operator()(bool const& x) const { return (::PyBool_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyBool_Type); } }; namespace converter { template <> struct arg_to_python< bool > : handle<> { arg_to_python(bool const& x) : python::handle<>(::PyBool_FromLong(x)) {} }; }
+
+
+
+
+
+template <> struct to_python_value<signed char&> : detail::builtin_to_python { inline PyObject* operator()(signed char const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed char const&> : detail::builtin_to_python { inline PyObject* operator()(signed char const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed char > : handle<> { arg_to_python(signed char const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned char&> : detail::builtin_to_python { inline PyObject* operator()(unsigned char const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned char const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned char const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned char > : handle<> { arg_to_python(unsigned char const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }
+
+template <> struct to_python_value<signed short&> : detail::builtin_to_python { inline PyObject* operator()(signed short const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed short const&> : detail::builtin_to_python { inline PyObject* operator()(signed short const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed short > : handle<> { arg_to_python(signed short const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned short&> : detail::builtin_to_python { inline PyObject* operator()(unsigned short const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned short const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned short const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned short > : handle<> { arg_to_python(unsigned short const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }
+template <> struct to_python_value<signed int&> : detail::builtin_to_python { inline PyObject* operator()(signed int const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed int const&> : detail::builtin_to_python { inline PyObject* operator()(signed int const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed int > : handle<> { arg_to_python(signed int const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned int&> : detail::builtin_to_python { inline PyObject* operator()(unsigned int const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned int const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned int const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned int > : handle<> { arg_to_python(unsigned int const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }
+template <> struct to_python_value<signed long&> : detail::builtin_to_python { inline PyObject* operator()(signed long const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<signed long const&> : detail::builtin_to_python { inline PyObject* operator()(signed long const& x) const { return (::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< signed long > : handle<> { arg_to_python(signed long const& x) : python::handle<>(::PyInt_FromLong(x)) {} }; } template <> struct to_python_value<unsigned long&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; template <> struct to_python_value<unsigned long const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long const& x) const { return (static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyInt_Type); } }; namespace converter { template <> struct arg_to_python< unsigned long > : handle<> { arg_to_python(unsigned long const& x) : python::handle<>(static_cast<unsigned long>(x) > static_cast<unsigned long>( (std::numeric_limits<long>::max)()) ? ::PyLong_FromUnsignedLong(x) : ::PyInt_FromLong(x)) {} }; }
+
+
+
+
+template <> struct to_python_value<signed long long&> : detail::builtin_to_python { inline PyObject* operator()(signed long long const& x) const { return (::PyLong_FromLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; template <> struct to_python_value<signed long long const&> : detail::builtin_to_python { inline PyObject* operator()(signed long long const& x) const { return (::PyLong_FromLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; namespace converter { template <> struct arg_to_python< signed long long > : handle<> { arg_to_python(signed long long const& x) : python::handle<>(::PyLong_FromLongLong(x)) {} }; }
+template <> struct to_python_value<unsigned long long&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long long const& x) const { return (::PyLong_FromUnsignedLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; template <> struct to_python_value<unsigned long long const&> : detail::builtin_to_python { inline PyObject* operator()(unsigned long long const& x) const { return (::PyLong_FromUnsignedLongLong(x)); } inline PyTypeObject const* get_pytype() const { return (&PyLong_Type); } }; namespace converter { template <> struct arg_to_python< unsigned long long > : handle<> { arg_to_python(unsigned long long const& x) : python::handle<>(::PyLong_FromUnsignedLongLong(x)) {} }; }
+# 139 "/usr/include/boost-1_42/boost/python/converter/builtin_converters.hpp"
+template <> struct to_python_value<char&> : detail::builtin_to_python { inline PyObject* operator()(char const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; template <> struct to_python_value<char const&> : detail::builtin_to_python { inline PyObject* operator()(char const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; namespace converter { template <> struct arg_to_python< char > : handle<> { arg_to_python(char const& x) : python::handle<>(converter::do_return_to_python(x)) {} }; }
+template <> struct to_python_value<char const*&> : detail::builtin_to_python { inline PyObject* operator()(char const* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; template <> struct to_python_value<char const* const&> : detail::builtin_to_python { inline PyObject* operator()(char const* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; namespace converter { template <> struct arg_to_python< char const* > : handle<> { arg_to_python(char const* const& x) : python::handle<>(converter::do_return_to_python(x)) {} }; }
+template <> struct to_python_value<std::string&> : detail::builtin_to_python { inline PyObject* operator()(std::string const& x) const { return (::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; template <> struct to_python_value<std::string const&> : detail::builtin_to_python { inline PyObject* operator()(std::string const& x) const { return (::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyString_Type); } }; namespace converter { template <> struct arg_to_python< std::string > : handle<> { arg_to_python(std::string const& x) : python::handle<>(::PyString_FromStringAndSize(x.data(),implicit_cast<ssize_t>(x.size()))) {} }; }
+
+
+
+template <> struct to_python_value<std::wstring&> : detail::builtin_to_python { inline PyObject* operator()(std::wstring const& x) const { return (::PyUnicodeUCS4_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyUnicode_Type); } }; template <> struct to_python_value<std::wstring const&> : detail::builtin_to_python { inline PyObject* operator()(std::wstring const& x) const { return (::PyUnicodeUCS4_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size()))); } inline PyTypeObject const* get_pytype() const { return (&PyUnicode_Type); } }; namespace converter { template <> struct arg_to_python< std::wstring > : handle<> { arg_to_python(std::wstring const& x) : python::handle<>(::PyUnicodeUCS4_FromWideChar(x.data(),implicit_cast<ssize_t>(x.size()))) {} }; }
+
+template <> struct to_python_value<float&> : detail::builtin_to_python { inline PyObject* operator()(float const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; template <> struct to_python_value<float const&> : detail::builtin_to_python { inline PyObject* operator()(float const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; namespace converter { template <> struct arg_to_python< float > : handle<> { arg_to_python(float const& x) : python::handle<>(::PyFloat_FromDouble(x)) {} }; }
+template <> struct to_python_value<double&> : detail::builtin_to_python { inline PyObject* operator()(double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; template <> struct to_python_value<double const&> : detail::builtin_to_python { inline PyObject* operator()(double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; namespace converter { template <> struct arg_to_python< double > : handle<> { arg_to_python(double const& x) : python::handle<>(::PyFloat_FromDouble(x)) {} }; }
+template <> struct to_python_value<long double&> : detail::builtin_to_python { inline PyObject* operator()(long double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; template <> struct to_python_value<long double const&> : detail::builtin_to_python { inline PyObject* operator()(long double const& x) const { return (::PyFloat_FromDouble(x)); } inline PyTypeObject const* get_pytype() const { return (&PyFloat_Type); } }; namespace converter { template <> struct arg_to_python< long double > : handle<> { arg_to_python(long double const& x) : python::handle<>(::PyFloat_FromDouble(x)) {} }; }
+template <> struct to_python_value<PyObject*&> : detail::builtin_to_python { inline PyObject* operator()(PyObject* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (0); } }; template <> struct to_python_value<PyObject* const&> : detail::builtin_to_python { inline PyObject* operator()(PyObject* const& x) const { return (converter::do_return_to_python(x)); } inline PyTypeObject const* get_pytype() const { return (0); } };
+template <> struct to_python_value<std::complex<float>&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<float> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; template <> struct to_python_value<std::complex<float> const&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<float> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; namespace converter { template <> struct arg_to_python< std::complex<float> > : handle<> { arg_to_python(std::complex<float> const& x) : python::handle<>(::PyComplex_FromDoubles(x.real(), x.imag())) {} }; }
+template <> struct to_python_value<std::complex<double>&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; template <> struct to_python_value<std::complex<double> const&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; namespace converter { template <> struct arg_to_python< std::complex<double> > : handle<> { arg_to_python(std::complex<double> const& x) : python::handle<>(::PyComplex_FromDoubles(x.real(), x.imag())) {} }; }
+template <> struct to_python_value<std::complex<long double>&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<long double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; template <> struct to_python_value<std::complex<long double> const&> : detail::builtin_to_python { inline PyObject* operator()(std::complex<long double> const& x) const { return (::PyComplex_FromDoubles(x.real(), x.imag())); } inline PyTypeObject const* get_pytype() const { return (&PyComplex_Type); } }; namespace converter { template <> struct arg_to_python< std::complex<long double> > : handle<> { arg_to_python(std::complex<long double> const& x) : python::handle<>(::PyComplex_FromDoubles(x.real(), x.imag())) {} }; }
+
+
+
+
+
+
+namespace converter
+{
+
+  void initialize_builtin_converters();
+
+}
+
+}}
+# 18 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing_params.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repetition/enum_trailing_binary_params.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/to_python_value.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/python/to_python_value.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/pyobject_type.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/converter/pyobject_type.hpp"
+namespace boost { namespace python { namespace converter {
+
+ PyObject* checked_downcast_impl(PyObject*, PyTypeObject*);
+
+
+
+template <class Object, PyTypeObject* pytype>
+struct pyobject_type
+{
+    static bool check(PyObject* x)
+    {
+        return ::PyObject_IsInstance(x, (PyObject*)pytype);
+    }
+
+    static Object* checked_downcast(PyObject* x)
+    {
+        return python::downcast<Object>(
+            (checked_downcast_impl)(x, pytype)
+            );
+    }
+
+    static PyTypeObject const* get_pytype() { return pytype; }
+
+};
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp" 2
+
+namespace boost { namespace python { namespace converter {
+
+template <class> struct pyobject_traits;
+
+template <>
+struct pyobject_traits<PyObject>
+{
+
+    static bool check(PyObject*) { return true; }
+    static PyObject* checked_downcast(PyObject* x) { return x; }
+
+    static PyTypeObject const* get_pytype() { return 0; }
+
+};
+# 35 "/usr/include/boost-1_42/boost/python/converter/pyobject_traits.hpp"
+template <> struct pyobject_traits<PyTypeObject> : pyobject_type<PyTypeObject, &PyType_Type> {};
+template <> struct pyobject_traits<PyListObject> : pyobject_type<PyListObject, &PyList_Type> {};
+
+template <> struct pyobject_traits<PyIntObject> : pyobject_type<PyIntObject, &PyInt_Type> {};
+
+template <> struct pyobject_traits<PyLongObject> : pyobject_type<PyLongObject, &PyLong_Type> {};
+template <> struct pyobject_traits<PyDictObject> : pyobject_type<PyDictObject, &PyDict_Type> {};
+template <> struct pyobject_traits<PyTupleObject> : pyobject_type<PyTupleObject, &PyTuple_Type> {};
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp" 2
+# 65 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp"
+namespace boost { namespace python
+{
+  namespace api
+  {
+    class object;
+  }
+}}
+
+namespace boost { namespace python { namespace converter {
+
+
+
+template <class T>
+struct handle_object_manager_traits
+    : pyobject_traits<typename T::element_type>
+{
+ private:
+  typedef pyobject_traits<typename T::element_type> base;
+
+ public:
+  static const bool is_specialized = true;
+
+
+
+  static null_ok<typename T::element_type>* adopt(PyObject* p)
+  {
+      return python::allow_null(base::checked_downcast(p));
+  }
+};
+
+template <class T>
+struct default_object_manager_traits
+{
+    static const bool is_specialized = python::detail::is_borrowed_ptr<T>::value
+
+         ;
+};
+
+template <class T>
+struct object_manager_traits
+    : mpl::if_c<
+         is_handle<T>::value
+       , handle_object_manager_traits<T>
+       , default_object_manager_traits<T>
+    >::type
+{
+};
+
+
+
+
+
+
+template <class T>
+struct is_object_manager
+    : mpl::bool_<object_manager_traits<T>::is_specialized>
+{
+};
+
+
+template <class T>
+struct is_reference_to_object_manager
+    : mpl::false_
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T const&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T volatile&>
+    : is_object_manager<T>
+{
+};
+
+template <class T>
+struct is_reference_to_object_manager<T const volatile&>
+    : is_object_manager<T>
+{
+};
+# 228 "/usr/include/boost-1_42/boost/python/converter/object_manager.hpp"
+}}}
+# 18 "/usr/include/boost-1_42/boost/python/to_python_value.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/value_is_shared_ptr.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/value_is_xxx.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/detail/value_is_shared_ptr.hpp" 2
+
+
+namespace boost { namespace python { namespace detail {
+
+template <class X_> struct value_is_shared_ptr { template <class T> struct is_shared_ptr : mpl::false_ { }; template < class T0 > struct is_shared_ptr< shared_ptr< T0 > > : mpl::true_ { }; static const bool value = is_shared_ptr< typename remove_cv< typename remove_reference<X_>::type >::type >::value; typedef mpl::bool_<value> type; };
+
+}}}
+# 21 "/usr/include/boost-1_42/boost/python/to_python_value.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/python/to_python_value.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+template <bool is_const_ref>
+struct object_manager_get_pytype
+{
+   template <class U>
+   static PyTypeObject const* get( U& (*)() =0)
+   {
+      return converter::object_manager_traits<U>::get_pytype();
+   }
+};
+
+template <>
+struct object_manager_get_pytype<true>
+{
+   template <class U>
+   static PyTypeObject const* get( U const& (*)() =0)
+   {
+      return converter::object_manager_traits<U>::get_pytype();
+   }
+};
+
+
+
+  template <class T>
+  struct object_manager_to_python_value
+  {
+      typedef typename value_arg<T>::type argument_type;
+
+      PyObject* operator()(argument_type) const;
+
+      typedef boost::mpl::bool_<is_handle<T>::value> is_t_handle;
+      typedef boost::detail::indirect_traits::is_reference_to_const<T> is_t_const;
+      PyTypeObject const* get_pytype() const {
+          return get_pytype_aux((is_t_handle*)0);
+      }
+
+      inline static PyTypeObject const* get_pytype_aux(mpl::true_*) {return converter::object_manager_traits<T>::get_pytype();}
+
+      inline static PyTypeObject const* get_pytype_aux(mpl::false_* )
+      {
+          return object_manager_get_pytype<is_t_const::value>::get((T(*)())0);
+      }
+
+
+
+
+
+
+      static const bool uses_registry = false;
+  };
+
+
+  template <class T>
+  struct registry_to_python_value
+  {
+      typedef typename value_arg<T>::type argument_type;
+
+      PyObject* operator()(argument_type) const;
+
+      PyTypeObject const* get_pytype() const {return converter::registered<T>::converters.to_python_target_type();}
+
+
+
+
+
+      static const bool uses_registry = true;
+  };
+
+  template <class T>
+  struct shared_ptr_to_python_value
+  {
+      typedef typename value_arg<T>::type argument_type;
+
+      PyObject* operator()(argument_type) const;
+
+      PyTypeObject const* get_pytype() const {return get_pytype((boost::type<argument_type>*)0);}
+
+
+
+
+      static const bool uses_registry = false;
+  private:
+
+      template <class U>
+      PyTypeObject const* get_pytype(boost::type<shared_ptr<U> &> *) const {return converter::registered<U>::converters.to_python_target_type();}
+      template <class U>
+      PyTypeObject const* get_pytype(boost::type<const shared_ptr<U> &> *) const {return converter::registered<U>::converters.to_python_target_type();}
+
+  };
+}
+
+template <class T>
+struct to_python_value
+    : mpl::if_<
+          detail::value_is_shared_ptr<T>
+        , detail::shared_ptr_to_python_value<T>
+        , typename mpl::if_<
+              mpl::or_<
+                  converter::is_object_manager<T>
+                , converter::is_reference_to_object_manager<T>
+              >
+            , detail::object_manager_to_python_value<T>
+            , detail::registry_to_python_value<T>
+          >::type
+      >::type
+{
+};
+
+
+
+
+namespace detail
+{
+  template <class T>
+  inline PyObject* registry_to_python_value<T>::operator()(argument_type x) const
+  {
+      typedef converter::registered<argument_type> r;
+
+
+
+
+      return converter::registered<argument_type>::converters.to_python(&x);
+  }
+
+  template <class T>
+  inline PyObject* object_manager_to_python_value<T>::operator()(argument_type x) const
+  {
+      return python::upcast<PyObject>(
+          python::xincref(
+              get_managed_object(x, tag))
+          );
+  }
+
+  template <class T>
+  inline PyObject* shared_ptr_to_python_value<T>::operator()(argument_type x) const
+  {
+      return converter::shared_ptr_to_python(x);
+  }
+}
+
+}}
+# 22 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2
+# 41 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+namespace boost { namespace python { namespace detail {
+
+
+
+typedef int void_result_to_python;
+
+template <bool void_return, bool member>
+struct invoke_tag_ {};
+
+
+
+template <class R, class F>
+struct invoke_tag
+  : invoke_tag_<
+        is_same<R,void>::value
+      , is_member_function_pointer<F>::value
+    >
+{
+};
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F >
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f )
+{
+    return rc(f( ));
+}
+
+template <class RC, class F >
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f )
+{
+    f( );
+    return none();
+}
+
+template <class RC, class F, class TC >
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc )
+{
+    return rc( (tc().*f)() );
+}
+
+template <class RC, class F, class TC >
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc )
+{
+    (tc().*f)();
+    return none();
+}
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 )
+{
+    return rc(f( ac0 () ));
+}
+
+template <class RC, class F , class AC0>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 )
+{
+    f( ac0 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 )
+{
+    return rc( (tc().*f)( ac0 () ) );
+}
+
+template <class RC, class F, class TC , class AC0>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 )
+{
+    (tc().*f)( ac0 () );
+    return none();
+}
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 )
+{
+    return rc(f( ac0 () , ac1 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 )
+{
+    f( ac0 () , ac1 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 )
+{
+    (tc().*f)( ac0 () , ac1 () );
+    return none();
+}
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
+{
+    f( ac0 () , ac1 () , ac2 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () );
+    return none();
+}
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () );
+    return none();
+}
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () );
+    return none();
+}
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () );
+    return none();
+}
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () );
+    return none();
+}
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () );
+    return none();
+}
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () );
+    return none();
+}
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () );
+    return none();
+}
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () );
+    return none();
+}
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () );
+    return none();
+}
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () );
+    return none();
+}
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () );
+    return none();
+}
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 1
+# 72 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp"
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
+inline PyObject* invoke(invoke_tag_<false,false>, RC const& rc, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
+{
+    return rc(f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () ));
+}
+
+template <class RC, class F , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
+inline PyObject* invoke(invoke_tag_<true,false>, RC const&, F& f , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
+{
+    f( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () );
+    return none();
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
+inline PyObject* invoke(invoke_tag_<false,true>, RC const& rc, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
+{
+    return rc( (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () ) );
+}
+
+template <class RC, class F, class TC , class AC0 , class AC1 , class AC2 , class AC3 , class AC4 , class AC5 , class AC6 , class AC7 , class AC8 , class AC9 , class AC10 , class AC11 , class AC12 , class AC13 , class AC14>
+inline PyObject* invoke(invoke_tag_<true,true>, RC const&, F& f, TC& tc , AC0 & ac0 , AC1 & ac1 , AC2 & ac2 , AC3 & ac3 , AC4 & ac4 , AC5 & ac5 , AC6 & ac6 , AC7 & ac7 , AC8 & ac8 , AC9 & ac9 , AC10 & ac10 , AC11 & ac11 , AC12 & ac12 , AC13 & ac13 , AC14 & ac14 )
+{
+    (tc().*f)( ac0 () , ac1 () , ac2 () , ac3 () , ac4 () , ac5 () , ac6 () , ac7 () , ac8 () , ac9 () , ac10 () , ac11 () , ac12 () , ac13 () , ac14 () );
+    return none();
+}
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 64 "/usr/include/boost-1_42/boost/python/detail/invoke.hpp" 2
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/at.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/at.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/sequence_tag_fwd.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/sequence_tag_fwd.hpp"
+namespace boost { namespace mpl {
+
+struct nested_begin_end_tag;
+struct non_sequence_tag;
+
+template< typename Sequence > struct sequence_tag;
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_begin.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_begin.hpp"
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::begin>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/traits_lambda_spec.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp" 2
+
+
+namespace boost { namespace mpl {
+
+
+namespace aux {
+
+template< typename Sequence >
+struct begin_type
+{
+    typedef typename Sequence::begin type;
+};
+template< typename Sequence >
+struct end_type
+{
+    typedef typename Sequence::end type;
+};
+
+}
+
+
+
+
+
+template< typename Tag >
+struct begin_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::begin_type<Sequence>, void_>::type type;
+    };
+};
+
+template< typename Tag >
+struct end_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename eval_if<aux::has_begin<Sequence, true_>,
+                                 aux::end_type<Sequence>, void_>::type type;
+    };
+};
+# 82 "/usr/include/boost-1_42/boost/mpl/aux_/begin_end_impl.hpp"
+template<> struct begin_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; };
+template<> struct end_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; };
+
+
+
+
+template<> struct begin_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct end_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct begin_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
+template<> struct end_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
+
+
+
+
+
+
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp"
+namespace boost { namespace mpl {
+# 78 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp"
+namespace aux {
+
+template< bool has_tag_, bool has_begin_ >
+struct sequence_tag_impl
+{
+
+
+    template< typename Sequence > struct result2_;
+};
+# 98 "/usr/include/boost-1_42/boost/mpl/sequence_tag.hpp"
+template<> struct sequence_tag_impl<true,true> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
+template<> struct sequence_tag_impl<true,false> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
+template<> struct sequence_tag_impl<false,true> { template< typename Sequence > struct result2_ { typedef nested_begin_end_tag type; }; };
+template<> struct sequence_tag_impl<false,false> { template< typename Sequence > struct result2_ { typedef non_sequence_tag type; }; };
+
+
+
+}
+
+template<
+      typename Sequence = na
+    >
+struct sequence_tag
+    : aux::sequence_tag_impl<
+          ::boost::mpl::aux::has_tag<Sequence>::value
+        , ::boost::mpl::aux::has_begin<Sequence>::value
+        >::template result2_<Sequence>
+{
+};
+
+
+
+template<> struct sequence_tag< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sequence_tag< T1 > { }; }; template< typename Tag > struct lambda< sequence_tag< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sequence_tag< na > result_; typedef sequence_tag< na > type; }; namespace aux { template< typename T1 > struct template_arity< sequence_tag< T1 > > : int_<1> { }; template<> struct template_arity< sequence_tag< na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/begin_end.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+
+
+
+template<
+      typename Sequence = na
+    >
+struct begin
+{
+    typedef typename sequence_tag<Sequence>::type tag_;
+    typedef typename begin_impl< tag_ >
+        ::template apply< Sequence >::type type;
+
+   
+};
+
+template<
+      typename Sequence = na
+    >
+struct end
+{
+    typedef typename sequence_tag<Sequence>::type tag_;
+    typedef typename end_impl< tag_ >
+        ::template apply< Sequence >::type type;
+
+   
+};
+
+template<> struct begin< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : begin< T1 > { }; }; template< typename Tag > struct lambda< begin< na > , Tag , int_<-1> > { typedef false_ is_le; typedef begin< na > result_; typedef begin< na > type; }; namespace aux { template< typename T1 > struct template_arity< begin< T1 > > : int_<1> { }; template<> struct template_arity< begin< na > > : int_<-1> { }; }
+template<> struct end< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : end< T1 > { }; }; template< typename Tag > struct lambda< end< na > , Tag , int_<-1> > { typedef false_ is_le; typedef end< na > result_; typedef end< na > type; }; namespace aux { template< typename T1 > struct template_arity< end< T1 > > : int_<1> { }; template<> struct template_arity< end< na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/advance.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/less.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/less.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/less.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct less_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct less_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct less_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct less_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct less_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct less
+
+    : less_impl<
+          typename less_tag<N1>::type
+        , typename less_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+};
+
+template<> struct less< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less< T1 , T2 > { }; }; template< typename Tag > struct lambda< less< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less< na , na > result_; typedef less< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+
+template<>
+struct less_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : bool_< ( N2::value > N1::value ) >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/less.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/negate.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/mpl/negate.hpp"
+namespace boost { namespace mpl {
+
+template< typename Tag > struct negate_impl;
+
+template< typename T > struct negate_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N = na
+    >
+struct negate
+
+    : negate_impl<
+          typename negate_tag<N>::type
+        >::template apply<N>::type
+
+
+
+
+
+
+{
+   
+};
+
+template<> struct negate< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : negate< T1 > { }; }; template< typename Tag > struct lambda< negate< na > , Tag , int_<-1> > { typedef false_ is_le; typedef negate< na > result_; typedef negate< na > type; }; namespace aux { template< typename T1 > struct template_arity< negate< T1 > > : int_<1> { }; template<> struct template_arity< negate< na > > : int_<-1> { }; }
+# 65 "/usr/include/boost-1_42/boost/mpl/negate.hpp"
+template<>
+struct negate_impl<integral_c_tag>
+{
+
+
+
+
+    template< typename N > struct apply
+        : integral_c< typename N::value_type, (-N::value) >
+
+    {
+    };
+};
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< long N > struct advance_forward;
+template<>
+struct advance_forward<0>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef iter0 type;
+    };
+};
+
+template<>
+struct advance_forward<1>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef iter1 type;
+    };
+};
+
+template<>
+struct advance_forward<2>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef typename next<iter1>::type iter2;
+        typedef iter2 type;
+    };
+};
+
+template<>
+struct advance_forward<3>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef typename next<iter1>::type iter2;
+        typedef typename next<iter2>::type iter3;
+        typedef iter3 type;
+    };
+};
+
+template<>
+struct advance_forward<4>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename next<iter0>::type iter1;
+        typedef typename next<iter1>::type iter2;
+        typedef typename next<iter2>::type iter3;
+        typedef typename next<iter3>::type iter4;
+        typedef iter4 type;
+    };
+};
+
+template< long N >
+struct advance_forward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename apply_wrap1<
+              advance_forward<4>
+            , Iterator
+            >::type chunk_result_;
+
+        typedef typename apply_wrap1<
+              advance_forward<(
+                (N - 4) < 0
+                    ? 0
+                    : N - 4
+                    )>
+            , chunk_result_
+            >::type type;
+    };
+};
+
+}}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/mpl/aux_/advance_forward.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp" 2
+# 32 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< long N > struct advance_backward;
+template<>
+struct advance_backward<0>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef iter0 type;
+    };
+};
+
+template<>
+struct advance_backward<1>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef iter1 type;
+    };
+};
+
+template<>
+struct advance_backward<2>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef typename prior<iter1>::type iter2;
+        typedef iter2 type;
+    };
+};
+
+template<>
+struct advance_backward<3>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef typename prior<iter1>::type iter2;
+        typedef typename prior<iter2>::type iter3;
+        typedef iter3 type;
+    };
+};
+
+template<>
+struct advance_backward<4>
+{
+    template< typename Iterator > struct apply
+    {
+        typedef Iterator iter0;
+        typedef typename prior<iter0>::type iter1;
+        typedef typename prior<iter1>::type iter2;
+        typedef typename prior<iter2>::type iter3;
+        typedef typename prior<iter3>::type iter4;
+        typedef iter4 type;
+    };
+};
+
+template< long N >
+struct advance_backward
+{
+    template< typename Iterator > struct apply
+    {
+        typedef typename apply_wrap1<
+              advance_backward<4>
+            , Iterator
+            >::type chunk_result_;
+
+        typedef typename apply_wrap1<
+              advance_backward<(
+                (N - 4) < 0
+                    ? 0
+                    : N - 4
+                    )>
+            , chunk_result_
+            >::type type;
+    };
+};
+
+}}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/mpl/aux_/advance_backward.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/mpl/advance.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+
+template< typename Tag >
+struct advance_impl
+{
+    template< typename Iterator, typename N > struct apply
+    {
+        typedef typename less< N,long_<0> >::type backward_;
+        typedef typename if_< backward_, negate<N>, N >::type offset_;
+
+        typedef typename if_<
+              backward_
+            , aux::advance_backward< offset_::value >
+            , aux::advance_forward< offset_::value >
+            >::type f_;
+
+        typedef typename apply_wrap1<f_,Iterator>::type type;
+    };
+};
+
+
+template<
+      typename Iterator = na
+    , typename N = na
+    >
+struct advance
+    : advance_impl< typename tag<Iterator>::type >
+        ::template apply<Iterator,N>
+{
+};
+
+template<
+      typename Iterator
+    , long N
+    >
+struct advance_c
+    : advance_impl< typename tag<Iterator>::type >
+        ::template apply<Iterator,long_<N> >
+{
+};
+
+template<> struct advance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : advance< T1 , T2 > { }; }; template< typename Tag > struct lambda< advance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef advance< na , na > result_; typedef advance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< advance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< advance< na , na > > : int_<-1> { }; }
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/deref.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/deref.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_type.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_type.hpp"
+namespace boost { namespace mpl { namespace aux {
+# 48 "/usr/include/boost-1_42/boost/mpl/aux_/msvc_type.hpp"
+template< typename T > struct msvc_type
+{
+    typedef typename T::type type;
+};
+
+template<> struct msvc_type<int>
+{
+    typedef int type;
+};
+
+
+
+}}}
+# 18 "/usr/include/boost-1_42/boost/mpl/deref.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Iterator = na
+    >
+struct deref
+{
+
+    typedef typename Iterator::type type;
+
+
+
+   
+};
+
+template<> struct deref< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : deref< T1 > { }; }; template< typename Tag > struct lambda< deref< na > , Tag , int_<-1> > { typedef false_ is_le; typedef deref< na > result_; typedef deref< na > type; }; namespace aux { template< typename T1 > struct template_arity< deref< T1 > > : int_<1> { }; template<> struct template_arity< deref< na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/at_impl.hpp" 2
+
+
+namespace boost { namespace mpl {
+
+
+
+
+template< typename Tag >
+struct at_impl
+{
+    template< typename Sequence, typename N > struct apply
+    {
+        typedef typename advance<
+              typename begin<Sequence>::type
+            , N
+            >::type iter_;
+
+        typedef typename deref<iter_>::type type;
+    };
+};
+
+ template<> struct at_impl<non_sequence_tag> {};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/at.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    , typename N = na
+    >
+struct at
+    : at_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,N >
+{
+   
+};
+
+template<
+      typename Sequence
+    , long N
+    >
+struct at_c
+    : at_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,mpl::long_<N> >
+{
+};
+
+template<> struct at< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : at< T1 , T2 > { }; }; template< typename Tag > struct lambda< at< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef at< na , na > result_; typedef at< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< at< T1 , T2 > > : int_<2> { }; template<> struct template_arity< at< na , na > > : int_<-1> { }; }
+
+}}
+# 21 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/size.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/size.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/size_impl.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/size_impl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/distance.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/O1_size.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/O1_size.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/has_size.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/has_size.hpp"
+namespace boost { namespace mpl { namespace aux {
+template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_size { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::size>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
+}}}
+# 21 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp" 2
+
+
+
+
+
+namespace boost { namespace mpl {
+# 35 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
+namespace aux {
+template< typename Sequence > struct O1_size_impl
+    : Sequence::size
+{
+};
+}
+
+template< typename Tag >
+struct O1_size_impl
+{
+    template< typename Sequence > struct apply
+
+        : if_<
+              aux::has_size<Sequence>
+            , aux::O1_size_impl<Sequence>
+            , long_<-1>
+            >::type
+    {
+# 69 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
+    };
+};
+# 85 "/usr/include/boost-1_42/boost/mpl/aux_/O1_size_impl.hpp"
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/O1_size.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+
+template<
+      typename Sequence = na
+    >
+struct O1_size
+    : O1_size_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+   
+};
+
+template<> struct O1_size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : O1_size< T1 > { }; }; template< typename Tag > struct lambda< O1_size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef O1_size< na > result_; typedef O1_size< na > type; }; namespace aux { template< typename T1 > struct template_arity< O1_size< T1 > > : int_<1> { }; template<> struct template_arity< O1_size< na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+
+
+template<
+      int N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl;
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 0,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef state0 state;
+    typedef iter0 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 1,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+
+
+    typedef state1 state;
+    typedef iter1 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 2,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+
+
+    typedef state2 state;
+    typedef iter2 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 3,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
+    typedef typename mpl::next<iter2>::type iter3;
+
+
+    typedef state3 state;
+    typedef iter3 iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< 4,First,Last,State,ForwardOp >
+{
+    typedef First iter0;
+    typedef State state0;
+    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
+    typedef typename mpl::next<iter0>::type iter1;
+    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
+    typedef typename mpl::next<iter1>::type iter2;
+    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
+    typedef typename mpl::next<iter2>::type iter3;
+    typedef typename apply2< ForwardOp,state3,iter3 >::type state4;
+    typedef typename mpl::next<iter3>::type iter4;
+
+
+    typedef state4 state;
+    typedef iter4 iterator;
+};
+
+template<
+      int N
+    , typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl
+{
+    typedef iter_fold_impl<
+          4
+        , First
+        , Last
+        , State
+        , ForwardOp
+        > chunk_;
+
+    typedef iter_fold_impl<
+          ( (N - 4) < 0 ? 0 : N - 4 )
+        , typename chunk_::iterator
+        , Last
+        , typename chunk_::state
+        , ForwardOp
+        > res_;
+
+    typedef typename res_::state state;
+    typedef typename res_::iterator iterator;
+};
+
+template<
+      typename First
+    , typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< -1,First,Last,State,ForwardOp >
+    : iter_fold_impl<
+          -1
+        , typename mpl::next<First>::type
+        , Last
+        , typename apply2< ForwardOp,State,First >::type
+        , ForwardOp
+        >
+{
+};
+
+template<
+      typename Last
+    , typename State
+    , typename ForwardOp
+    >
+struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
+{
+    typedef State state;
+    typedef Last iterator;
+};
+
+}}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 34 "/usr/include/boost-1_42/boost/mpl/aux_/iter_fold_impl.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/mpl/iter_fold.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    , typename State = na
+    , typename ForwardOp = na
+    >
+struct iter_fold
+{
+    typedef typename aux::iter_fold_impl<
+          ::boost::mpl::O1_size<Sequence>::value
+        , typename begin<Sequence>::type
+        , typename end<Sequence>::type
+        , State
+        , typename lambda<ForwardOp>::type
+        >::state type;
+
+   
+};
+
+template<> struct iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold< na , na , na > result_; typedef iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< iter_fold< na , na , na > > : int_<-1> { }; }
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/iterator_range.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/iterator_range.hpp"
+namespace boost { namespace mpl {
+
+struct iterator_range_tag;
+
+template<
+      typename First = na
+    , typename Last = na
+    >
+struct iterator_range
+{
+    typedef iterator_range_tag tag;
+    typedef iterator_range type;
+    typedef First begin;
+    typedef Last end;
+
+   
+};
+
+template<> struct iterator_range< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_range< T1 , T2 > { }; }; template< typename Tag > struct lambda< iterator_range< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_range< na , na > result_; typedef iterator_range< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< iterator_range< T1 , T2 > > : int_<2> { }; template<> struct template_arity< iterator_range< na , na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/mpl/distance.hpp" 2
+
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+template< typename Tag > struct distance_impl
+{
+    template< typename First, typename Last > struct apply
+
+        : aux::msvc_eti_base< typename iter_fold<
+              iterator_range<First,Last>
+            , mpl::long_<0>
+            , next<>
+            >::type >
+    {
+# 60 "/usr/include/boost-1_42/boost/mpl/distance.hpp"
+    };
+};
+
+template<
+      typename First = na
+    , typename Last = na
+    >
+struct distance
+    : distance_impl< typename tag<First>::type >
+        ::template apply<First, Last>
+{
+   
+};
+
+template<> struct distance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : distance< T1 , T2 > { }; }; template< typename Tag > struct lambda< distance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef distance< na , na > result_; typedef distance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< distance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< distance< na , na > > : int_<-1> { }; }
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/size_impl.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+
+
+
+template< typename Tag >
+struct size_impl
+{
+    template< typename Sequence > struct apply
+
+        : distance<
+              typename begin<Sequence>::type
+            , typename end<Sequence>::type
+            >
+    {
+
+
+
+
+
+
+
+    };
+};
+
+ template<> struct size_impl<non_sequence_tag> {};
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/size.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    >
+struct size
+    : aux::msvc_eti_base<
+        typename size_impl< typename sequence_tag<Sequence>::type >
+            ::template apply< Sequence >::type
+      >::type
+{
+   
+};
+
+template<> struct size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : size< T1 > { }; }; template< typename Tag > struct lambda< size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef size< na > result_; typedef size< na > type; }; namespace aux { template< typename T1 > struct template_arity< size< T1 > > : int_<1> { }; template<> struct template_arity< size< na > > : int_<-1> { }; }
+
+}}
+# 22 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+struct signature_element
+{
+    char const* basename;
+    converter::pytype_function pytype_f;
+    bool lvalue;
+};
+
+struct py_func_sig_info
+{
+    signature_element const *signature;
+    signature_element const *ret;
+};
+
+template <unsigned> struct signature_arity;
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<0>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[0 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<1>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[1 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<2>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[2 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<3>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[3 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<4>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[4 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<5>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[5 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<6>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[6 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<7>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[7 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<8>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[8 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<9>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[9 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<10>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[10 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<11>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[11 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<12>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[12 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<13>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[13 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<14>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[14 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,14>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,14>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,14>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<15>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[15 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,14>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,14>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,14>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,15>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,15>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,15>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+template <>
+struct signature_arity<16>
+{
+    template <class Sig>
+    struct impl
+    {
+        static signature_element const* elements()
+        {
+            static signature_element const result[16 +2] = {
+# 96 "/usr/include/boost-1_42/boost/python/detail/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        { type_id<typename mpl::at_c<Sig,0>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,0>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,0>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,1>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,1>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,1>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,2>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,2>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,2>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,3>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,3>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,3>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,4>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,4>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,4>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,5>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,5>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,5>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,6>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,6>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,6>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,7>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,7>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,7>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,8>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,8>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,8>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,9>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,9>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,9>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,10>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,10>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,10>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,11>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,11>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,11>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,12>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,12>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,12>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,13>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,13>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,13>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,14>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,14>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,14>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,15>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,15>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,15>::type>::value },
+
+
+        { type_id<typename mpl::at_c<Sig,16>::type>().name() , &converter::expected_pytype_for_arg<typename mpl::at_c<Sig,16>::type>::get_pytype , indirect_traits::is_reference_to_non_const<typename mpl::at_c<Sig,16>::type>::value },
+# 97 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+                {0,0,0}
+            };
+            return result;
+        }
+    };
+};
+# 128 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 2
+
+
+
+
+
+template <class Sig>
+struct signature_base_select
+{
+    enum { arity = mpl::size<Sig>::value - 1 };
+    typedef typename signature_arity<arity>::template impl<Sig> type;
+};
+
+template <class Sig>
+struct signature
+    : signature_base_select<Sig>::type
+{
+};
+
+}}}
+# 18 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/arg_from_python.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/arg_from_python.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/from_python.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/converter/from_python.hpp"
+namespace boost { namespace python { namespace converter {
+
+struct registration;
+
+
+ void* get_lvalue_from_python(
+    PyObject* source, registration const&);
+
+ bool implicit_rvalue_convertible_from_python(
+    PyObject* source, registration const&);
+
+ rvalue_from_python_stage1_data rvalue_from_python_stage1(
+    PyObject* source, registration const&);
+
+ void* rvalue_from_python_stage2(
+    PyObject* source, rvalue_from_python_stage1_data&, registration const&);
+
+ void* rvalue_result_from_python(
+    PyObject*, rvalue_from_python_stage1_data&);
+
+ void* reference_result_from_python(PyObject*, registration const&);
+ void* pointer_result_from_python(PyObject*, registration const&);
+
+ void void_result_from_python(PyObject*);
+
+ void throw_no_pointer_from_python(PyObject*, registration const&);
+ void throw_no_reference_from_python(PyObject*, registration const&);
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/void_ptr.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/detail/void_ptr.hpp"
+namespace boost { namespace python { namespace detail {
+
+template <class U>
+inline U& void_ptr_to_reference(void const volatile* p, U&(*)())
+{
+    return *(U*)p;
+}
+
+template <class T>
+inline void write_void_ptr(void const volatile* storage, void* ptr, T*)
+{
+    *(T**)storage = (T*)ptr;
+}
+
+
+template <class U>
+inline void write_void_ptr_reference(void const volatile* storage, void* ptr, U&(*)())
+{
+
+    typedef typename remove_cv<U>::type u_stripped;
+    write_void_ptr(storage, ptr, u_stripped(0));
+}
+
+}}}
+# 24 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/back_reference.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/back_reference.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object_fwd.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object_fwd.hpp"
+namespace boost { namespace python {
+namespace api
+{
+  class object;
+}
+using api::object;
+}}
+# 11 "/usr/include/boost-1_42/boost/python/back_reference.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/dependent.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+# 19 "/usr/include/boost-1_42/boost/python/detail/dependent.hpp"
+template <class T, class U>
+struct dependent
+{
+    typedef T type;
+};
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/back_reference.hpp" 2
+
+
+namespace boost { namespace python {
+
+template <class T>
+struct back_reference
+{
+ private:
+    typedef typename detail::dependent<object,T>::type source_t;
+ public:
+    typedef T type;
+
+    back_reference(PyObject*, T);
+    source_t const& source() const;
+    T get() const;
+ private:
+    source_t m_source;
+    T m_value;
+};
+
+
+template<typename T>
+class is_back_reference
+{
+ public:
+    static const bool value = false;
+};
+
+template<typename T>
+class is_back_reference<back_reference<T> >
+{
+ public:
+    static const bool value = true;
+};
+# 81 "/usr/include/boost-1_42/boost/python/back_reference.hpp"
+template <class T>
+back_reference<T>::back_reference(PyObject* p, T x)
+    : m_source(detail::borrowed_reference(p))
+      , m_value(x)
+{
+}
+
+template <class T>
+typename back_reference<T>::source_t const& back_reference<T>::source() const
+{
+    return m_source;
+}
+
+template <class T>
+T back_reference<T>::get() const
+{
+    return m_value;
+}
+
+}}
+# 25 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/construct.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+template <class T, class Arg>
+void construct_pointee(void* storage, Arg& x
+
+                       , T const volatile*
+
+
+
+    )
+{
+    new (storage) T(x);
+}
+
+template <class T, class Arg>
+void construct_referent_impl(void* storage, Arg& x, T&(*)())
+{
+    construct_pointee(storage, x, (T*)0);
+}
+
+template <class T, class Arg>
+void construct_referent(void* storage, Arg const& x, T(*tag)() = 0)
+{
+    construct_referent_impl(storage, x, tag);
+}
+
+template <class T, class Arg>
+void construct_referent(void* storage, Arg& x, T(*tag)() = 0)
+{
+    construct_referent_impl(storage, x, tag);
+}
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp"
+namespace boost { namespace python { namespace converter {
+
+template <class T>
+struct object_manager_value_arg_from_python
+{
+    typedef T result_type;
+
+    object_manager_value_arg_from_python(PyObject*);
+    bool convertible() const;
+    T operator()() const;
+ private:
+    PyObject* m_source;
+};
+# 43 "/usr/include/boost-1_42/boost/python/converter/obj_mgr_arg_from_python.hpp"
+template <class Ref>
+struct object_manager_ref_arg_from_python
+{
+    typedef Ref result_type;
+
+    object_manager_ref_arg_from_python(PyObject*);
+    bool convertible() const;
+    Ref operator()() const;
+    ~object_manager_ref_arg_from_python();
+ private:
+    typename python::detail::referent_storage<Ref>::type m_result;
+};
+
+
+
+
+
+template <class T>
+inline object_manager_value_arg_from_python<T>::object_manager_value_arg_from_python(PyObject* x)
+    : m_source(x)
+{
+}
+
+template <class T>
+inline bool object_manager_value_arg_from_python<T>::convertible() const
+{
+    return object_manager_traits<T>::check(m_source);
+}
+
+template <class T>
+inline T object_manager_value_arg_from_python<T>::operator()() const
+{
+    return T(python::detail::borrowed_reference(m_source));
+}
+
+template <class Ref>
+inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_python(PyObject* x)
+{
+
+
+
+
+
+    python::detail::construct_referent<Ref>(&m_result.bytes, (python::detail::borrowed_reference)x);
+
+}
+
+template <class Ref>
+inline object_manager_ref_arg_from_python<Ref>::~object_manager_ref_arg_from_python()
+{
+    python::detail::destroy_referent<Ref>(this->m_result.bytes);
+}
+
+namespace detail
+{
+  template <class T>
+  inline bool object_manager_ref_check(T const& x)
+  {
+      return object_manager_traits<T>::check(get_managed_object(x, tag));
+  }
+}
+
+template <class Ref>
+inline bool object_manager_ref_arg_from_python<Ref>::convertible() const
+{
+    return detail::object_manager_ref_check(
+        python::detail::void_ptr_to_reference(this->m_result.bytes, (Ref(*)())0));
+}
+
+template <class Ref>
+inline Ref object_manager_ref_arg_from_python<Ref>::operator()() const
+{
+    return python::detail::void_ptr_to_reference(
+        this->m_result.bytes, (Ref(*)())0);
+}
+
+}}}
+# 27 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp" 2
+
+namespace boost { namespace python
+{
+  template <class T> struct arg_from_python;
+}}
+
+
+
+
+namespace boost { namespace python { namespace converter {
+# 45 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
+template <class T>
+struct pointer_cref_arg_from_python
+{
+    typedef T result_type;
+
+    pointer_cref_arg_from_python(PyObject*);
+    T operator()() const;
+    bool convertible() const;
+
+ private:
+
+
+    typename python::detail::referent_storage<T>::type m_result;
+};
+
+
+struct arg_lvalue_from_python_base
+{
+ public:
+    arg_lvalue_from_python_base(void* result);
+    bool convertible() const;
+
+ protected:
+    void*const& result() const;
+
+ private:
+    void* m_result;
+};
+
+
+template <class T>
+struct pointer_arg_from_python : arg_lvalue_from_python_base
+{
+    typedef T result_type;
+
+    pointer_arg_from_python(PyObject*);
+    T operator()() const;
+};
+
+
+template <class T>
+struct reference_arg_from_python : arg_lvalue_from_python_base
+{
+    typedef T result_type;
+
+    reference_arg_from_python(PyObject*);
+    T operator()() const;
+};
+# 106 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
+template <class T>
+struct arg_rvalue_from_python
+{
+    typedef typename boost::add_reference<
+        T
+
+
+    >::type result_type;
+
+    arg_rvalue_from_python(PyObject*);
+    bool convertible() const;
+
+
+    typename arg_rvalue_from_python<T>::
+
+    result_type operator()();
+
+ private:
+    rvalue_from_python_data<result_type> m_data;
+    PyObject* m_source;
+};
+
+
+
+
+
+
+template <class T>
+struct back_reference_arg_from_python
+    : boost::python::arg_from_python<typename T::type>
+{
+    typedef T result_type;
+
+    back_reference_arg_from_python(PyObject*);
+    T operator()();
+ private:
+    typedef boost::python::arg_from_python<typename T::type> base;
+    PyObject* m_source;
+};
+
+
+
+
+template <class C, class T, class F>
+struct if_2
+{
+    typedef typename mpl::eval_if<C, mpl::identity<T>, F>::type type;
+};
+
+
+
+template <class T>
+struct select_arg_from_python
+{
+    typedef typename if_2<
+        is_object_manager<T>
+      , object_manager_value_arg_from_python<T>
+      , if_2<
+            is_reference_to_object_manager<T>
+          , object_manager_ref_arg_from_python<T>
+          , if_2<
+                is_pointer<T>
+              , pointer_arg_from_python<T>
+              , if_2<
+                    mpl::and_<
+                        indirect_traits::is_reference_to_pointer<T>
+                      , indirect_traits::is_reference_to_const<T>
+                      , mpl::not_<indirect_traits::is_reference_to_volatile<T> >
+                        >
+                  , pointer_cref_arg_from_python<T>
+                  , if_2<
+                        mpl::or_<
+                            indirect_traits::is_reference_to_non_const<T>
+                          , indirect_traits::is_reference_to_volatile<T>
+                        >
+                      , reference_arg_from_python<T>
+                      , mpl::if_<
+                            boost::python::is_back_reference<T>
+                          , back_reference_arg_from_python<T>
+                          , arg_rvalue_from_python<T>
+                        >
+                    >
+                >
+            >
+        >
+    >::type type;
+};
+# 202 "/usr/include/boost-1_42/boost/python/converter/arg_from_python.hpp"
+inline arg_lvalue_from_python_base::arg_lvalue_from_python_base(void* result)
+    : m_result(result)
+{
+}
+
+inline bool arg_lvalue_from_python_base::convertible() const
+{
+    return m_result != 0;
+}
+
+inline void*const& arg_lvalue_from_python_base::result() const
+{
+    return m_result;
+}
+
+
+
+namespace detail
+{
+
+
+
+  template <class T>
+  struct null_ptr_owner
+  {
+      static T value;
+  };
+  template <class T> T null_ptr_owner<T>::value = 0;
+
+  template <class U>
+  inline U& null_ptr_reference(U&(*)())
+  {
+      return null_ptr_owner<U>::value;
+  }
+}
+
+template <class T>
+inline pointer_cref_arg_from_python<T>::pointer_cref_arg_from_python(PyObject* p)
+{
+
+
+
+    python::detail::write_void_ptr_reference(
+        m_result.bytes
+        , p == (&_Py_NoneStruct) ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters)
+        , (T(*)())0);
+}
+
+template <class T>
+inline bool pointer_cref_arg_from_python<T>::convertible() const
+{
+    return python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0) != 0;
+}
+template <class T>
+inline T pointer_cref_arg_from_python<T>::operator()() const
+{
+    return (*(void**)m_result.bytes == (&_Py_NoneStruct))
+        ? detail::null_ptr_reference((T(*)())0)
+
+        : python::detail::void_ptr_to_reference(m_result.bytes, (T(*)())0);
+}
+
+
+
+template <class T>
+inline pointer_arg_from_python<T>::pointer_arg_from_python(PyObject* p)
+    : arg_lvalue_from_python_base(
+        p == (&_Py_NoneStruct) ? p : converter::get_lvalue_from_python(p, registered_pointee<T>::converters))
+{
+}
+
+template <class T>
+inline T pointer_arg_from_python<T>::operator()() const
+{
+    return (result() == (&_Py_NoneStruct)) ? 0 : T(result());
+}
+
+
+
+template <class T>
+inline reference_arg_from_python<T>::reference_arg_from_python(PyObject* p)
+    : arg_lvalue_from_python_base(converter::get_lvalue_from_python(p,registered<T>::converters))
+{
+}
+
+template <class T>
+inline T reference_arg_from_python<T>::operator()() const
+{
+    return python::detail::void_ptr_to_reference(result(), (T(*)())0);
+}
+
+
+
+
+template <class T>
+inline arg_rvalue_from_python<T>::arg_rvalue_from_python(PyObject* obj)
+    : m_data(converter::rvalue_from_python_stage1(obj, registered<T>::converters))
+    , m_source(obj)
+{
+}
+
+template <class T>
+inline bool arg_rvalue_from_python<T>::convertible() const
+{
+    return m_data.stage1.convertible != 0;
+}
+
+template <class T>
+inline typename arg_rvalue_from_python<T>::result_type
+arg_rvalue_from_python<T>::operator()()
+{
+    if (m_data.stage1.construct != 0)
+        m_data.stage1.construct(m_source, &m_data.stage1);
+
+    return python::detail::void_ptr_to_reference(m_data.stage1.convertible, (result_type(*)())0);
+}
+
+
+
+template <class T>
+back_reference_arg_from_python<T>::back_reference_arg_from_python(PyObject* x)
+  : base(x), m_source(x)
+{
+}
+
+template <class T>
+inline T
+back_reference_arg_from_python<T>::operator()()
+{
+    return T(m_source, base::operator()());
+}
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/arg_from_python.hpp" 2
+
+
+
+
+
+namespace boost { namespace python {
+
+template <class T>
+struct arg_from_python
+    : converter::select_arg_from_python<
+
+
+
+
+          T
+
+      >::type
+{
+    typedef typename converter::select_arg_from_python<
+
+
+
+
+          T
+
+        >::type base;
+
+    arg_from_python(PyObject*);
+};
+
+
+template <>
+struct arg_from_python<PyObject*>
+{
+    typedef PyObject* result_type;
+
+    arg_from_python(PyObject* p) : m_source(p) {}
+    bool convertible() const { return true; }
+    PyObject* operator()() const { return m_source; }
+ private:
+    PyObject* m_source;
+};
+
+template <>
+struct arg_from_python<PyObject* const&>
+{
+    typedef PyObject* const& result_type;
+
+    arg_from_python(PyObject* p) : m_source(p) {}
+    bool convertible() const { return true; }
+    PyObject*const& operator()() const { return m_source; }
+ private:
+    PyObject* m_source;
+};
+
+
+
+
+template <class T>
+inline arg_from_python<T>::arg_from_python(PyObject* source)
+    : base(source)
+{
+}
+
+}}
+# 21 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/converter/context_result_converter.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace converter {
+
+
+
+
+struct context_result_converter {};
+
+}}}
+# 22 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/dec.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/preprocessor/if.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/compressed_pair.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/compressed_pair.hpp"
+# 1 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp"
+# 1 "/usr/include/boost-1_42/boost/call_traits.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/call_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/detail/call_traits.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/detail/call_traits.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 25 "/usr/include/boost-1_42/boost/detail/call_traits.hpp" 2
+
+
+
+
+
+namespace boost{
+
+namespace detail{
+
+template <typename T, bool small_>
+struct ct_imp2
+{
+   typedef const T& param_type;
+};
+
+template <typename T>
+struct ct_imp2<T, true>
+{
+   typedef const T param_type;
+};
+
+template <typename T, bool isp, bool b1>
+struct ct_imp
+{
+   typedef const T& param_type;
+};
+
+template <typename T, bool isp>
+struct ct_imp<T, isp, true>
+{
+   typedef typename ct_imp2<T, sizeof(T) <= sizeof(void*)>::param_type param_type;
+};
+
+template <typename T, bool b1>
+struct ct_imp<T, true, b1>
+{
+   typedef const T param_type;
+};
+
+}
+
+template <typename T>
+struct call_traits
+{
+public:
+   typedef T value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+
+
+
+
+
+
+   typedef typename boost::detail::ct_imp<
+      T,
+      ::boost::is_pointer<T>::value,
+      ::boost::is_arithmetic<T>::value
+   >::param_type param_type;
+};
+
+template <typename T>
+struct call_traits<T&>
+{
+   typedef T& value_type;
+   typedef T& reference;
+   typedef const T& const_reference;
+   typedef T& param_type;
+};
+# 135 "/usr/include/boost-1_42/boost/detail/call_traits.hpp"
+template <typename T, std::size_t BOOST_PP_ITERATION_0>
+struct call_traits<T [BOOST_PP_ITERATION_0]>
+{
+private:
+   typedef T array_type[BOOST_PP_ITERATION_0];
+public:
+
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+
+template <typename T, std::size_t BOOST_PP_ITERATION_0>
+struct call_traits<const T [BOOST_PP_ITERATION_0]>
+{
+private:
+   typedef const T array_type[BOOST_PP_ITERATION_0];
+public:
+
+   typedef const T* value_type;
+   typedef array_type& reference;
+   typedef const array_type& const_reference;
+   typedef const T* const param_type;
+};
+
+
+}
+# 22 "/usr/include/boost-1_42/boost/call_traits.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp" 2
+
+
+
+
+
+namespace boost
+{
+
+template <class T1, class T2>
+class compressed_pair;
+
+
+
+
+namespace details
+{
+
+   template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty>
+   struct compressed_pair_switch;
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, false, false>
+      {static const int value = 0;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, true, true>
+      {static const int value = 3;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, true, false>
+      {static const int value = 1;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, false, false, true>
+      {static const int value = 2;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, true, true, true>
+      {static const int value = 4;};
+
+   template <class T1, class T2>
+   struct compressed_pair_switch<T1, T2, true, false, false>
+      {static const int value = 5;};
+
+   template <class T1, class T2, int Version> class compressed_pair_imp;
+
+
+
+   using std::swap;
+
+
+
+
+
+
+   template <typename T>
+   inline void cp_swap(T& t1, T& t2)
+   {
+
+
+
+      swap(t1, t2);
+   }
+
+
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 0>
+   {
+   public:
+      typedef T1 first_type;
+      typedef T2 second_type;
+      typedef typename call_traits<first_type>::param_type first_param_type;
+      typedef typename call_traits<second_type>::param_type second_param_type;
+      typedef typename call_traits<first_type>::reference first_reference;
+      typedef typename call_traits<second_type>::reference second_reference;
+      typedef typename call_traits<first_type>::const_reference first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_(x), second_(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_(y) {}
+
+      first_reference first() {return first_;}
+      first_const_reference first() const {return first_;}
+
+      second_reference second() {return second_;}
+      second_const_reference second() const {return second_;}
+
+      void swap(::boost::compressed_pair<T1, T2>& y)
+      {
+         cp_swap(first_, y.first());
+         cp_swap(second_, y.second());
+      }
+   private:
+      first_type first_;
+      second_type second_;
+   };
+
+
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 1>
+      : protected ::boost::remove_cv<T1>::type
+   {
+   public:
+      typedef T1 first_type;
+      typedef T2 second_type;
+      typedef typename call_traits<first_type>::param_type first_param_type;
+      typedef typename call_traits<second_type>::param_type second_param_type;
+      typedef typename call_traits<first_type>::reference first_reference;
+      typedef typename call_traits<second_type>::reference second_reference;
+      typedef typename call_traits<first_type>::const_reference first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_type(x), second_(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_type(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_(y) {}
+
+      first_reference first() {return *this;}
+      first_const_reference first() const {return *this;}
+
+      second_reference second() {return second_;}
+      second_const_reference second() const {return second_;}
+
+      void swap(::boost::compressed_pair<T1,T2>& y)
+      {
+
+         cp_swap(second_, y.second());
+      }
+   private:
+      second_type second_;
+   };
+
+
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 2>
+      : protected ::boost::remove_cv<T2>::type
+   {
+   public:
+      typedef T1 first_type;
+      typedef T2 second_type;
+      typedef typename call_traits<first_type>::param_type first_param_type;
+      typedef typename call_traits<second_type>::param_type second_param_type;
+      typedef typename call_traits<first_type>::reference first_reference;
+      typedef typename call_traits<second_type>::reference second_reference;
+      typedef typename call_traits<first_type>::const_reference first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : second_type(y), first_(x) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_type(y) {}
+
+      first_reference first() {return first_;}
+      first_const_reference first() const {return first_;}
+
+      second_reference second() {return *this;}
+      second_const_reference second() const {return *this;}
+
+      void swap(::boost::compressed_pair<T1,T2>& y)
+      {
+
+         cp_swap(first_, y.first());
+      }
+
+   private:
+      first_type first_;
+   };
+
+
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 3>
+      : protected ::boost::remove_cv<T1>::type,
+        protected ::boost::remove_cv<T2>::type
+   {
+   public:
+      typedef T1 first_type;
+      typedef T2 second_type;
+      typedef typename call_traits<first_type>::param_type first_param_type;
+      typedef typename call_traits<second_type>::param_type second_param_type;
+      typedef typename call_traits<first_type>::reference first_reference;
+      typedef typename call_traits<second_type>::reference second_reference;
+      typedef typename call_traits<first_type>::const_reference first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_type(x), second_type(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_type(x) {}
+
+      compressed_pair_imp(second_param_type y)
+         : second_type(y) {}
+
+      first_reference first() {return *this;}
+      first_const_reference first() const {return *this;}
+
+      second_reference second() {return *this;}
+      second_const_reference second() const {return *this;}
+
+
+      void swap(::boost::compressed_pair<T1,T2>&) {}
+   };
+# 265 "/usr/include/boost-1_42/boost/detail/compressed_pair.hpp"
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 4>
+      : protected ::boost::remove_cv<T1>::type
+   {
+   public:
+      typedef T1 first_type;
+      typedef T2 second_type;
+      typedef typename call_traits<first_type>::param_type first_param_type;
+      typedef typename call_traits<second_type>::param_type second_param_type;
+      typedef typename call_traits<first_type>::reference first_reference;
+      typedef typename call_traits<second_type>::reference second_reference;
+      typedef typename call_traits<first_type>::const_reference first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_type(x), m_second(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_type(x), m_second(x) {}
+
+      first_reference first() {return *this;}
+      first_const_reference first() const {return *this;}
+
+      second_reference second() {return m_second;}
+      second_const_reference second() const {return m_second;}
+
+      void swap(::boost::compressed_pair<T1,T2>&) {}
+   private:
+      T2 m_second;
+   };
+
+
+
+   template <class T1, class T2>
+   class compressed_pair_imp<T1, T2, 5>
+   {
+   public:
+      typedef T1 first_type;
+      typedef T2 second_type;
+      typedef typename call_traits<first_type>::param_type first_param_type;
+      typedef typename call_traits<second_type>::param_type second_param_type;
+      typedef typename call_traits<first_type>::reference first_reference;
+      typedef typename call_traits<second_type>::reference second_reference;
+      typedef typename call_traits<first_type>::const_reference first_const_reference;
+      typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+      compressed_pair_imp() {}
+
+      compressed_pair_imp(first_param_type x, second_param_type y)
+         : first_(x), second_(y) {}
+
+      compressed_pair_imp(first_param_type x)
+         : first_(x), second_(x) {}
+
+      first_reference first() {return first_;}
+      first_const_reference first() const {return first_;}
+
+      second_reference second() {return second_;}
+      second_const_reference second() const {return second_;}
+
+      void swap(::boost::compressed_pair<T1, T2>& y)
+      {
+         cp_swap(first_, y.first());
+         cp_swap(second_, y.second());
+      }
+   private:
+      first_type first_;
+      second_type second_;
+   };
+
+}
+
+template <class T1, class T2>
+class compressed_pair
+   : private ::boost::details::compressed_pair_imp<T1, T2,
+             ::boost::details::compressed_pair_switch<
+                    T1,
+                    T2,
+                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
+                    ::boost::is_empty<T1>::value,
+                    ::boost::is_empty<T2>::value>::value>
+{
+private:
+   typedef details::compressed_pair_imp<T1, T2,
+             ::boost::details::compressed_pair_switch<
+                    T1,
+                    T2,
+                    ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value,
+                    ::boost::is_empty<T1>::value,
+                    ::boost::is_empty<T2>::value>::value> base;
+public:
+   typedef T1 first_type;
+   typedef T2 second_type;
+   typedef typename call_traits<first_type>::param_type first_param_type;
+   typedef typename call_traits<second_type>::param_type second_param_type;
+   typedef typename call_traits<first_type>::reference first_reference;
+   typedef typename call_traits<second_type>::reference second_reference;
+   typedef typename call_traits<first_type>::const_reference first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : base() {}
+            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
+   explicit compressed_pair(first_param_type x) : base(x) {}
+   explicit compressed_pair(second_param_type y) : base(y) {}
+
+   first_reference first() {return base::first();}
+   first_const_reference first() const {return base::first();}
+
+   second_reference second() {return base::second();}
+   second_const_reference second() const {return base::second();}
+
+   void swap(compressed_pair& y) { base::swap(y); }
+};
+
+
+
+
+template <class T>
+class compressed_pair<T, T>
+   : private details::compressed_pair_imp<T, T,
+             ::boost::details::compressed_pair_switch<
+                    T,
+                    T,
+                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
+                    ::boost::is_empty<T>::value,
+                    ::boost::is_empty<T>::value>::value>
+{
+private:
+   typedef details::compressed_pair_imp<T, T,
+             ::boost::details::compressed_pair_switch<
+                    T,
+                    T,
+                    ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value,
+                    ::boost::is_empty<T>::value,
+                    ::boost::is_empty<T>::value>::value> base;
+public:
+   typedef T first_type;
+   typedef T second_type;
+   typedef typename call_traits<first_type>::param_type first_param_type;
+   typedef typename call_traits<second_type>::param_type second_param_type;
+   typedef typename call_traits<first_type>::reference first_reference;
+   typedef typename call_traits<second_type>::reference second_reference;
+   typedef typename call_traits<first_type>::const_reference first_const_reference;
+   typedef typename call_traits<second_type>::const_reference second_const_reference;
+
+            compressed_pair() : base() {}
+            compressed_pair(first_param_type x, second_param_type y) : base(x, y) {}
+
+   explicit
+
+      compressed_pair(first_param_type x) : base(x) {}
+
+   first_reference first() {return base::first();}
+   first_const_reference first() const {return base::first();}
+
+   second_reference second() {return base::second();}
+   second_const_reference second() const {return base::second();}
+
+   void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); }
+};
+
+template <class T1, class T2>
+inline
+void
+swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y)
+{
+   x.swap(y);
+}
+
+}
+# 22 "/usr/include/boost-1_42/boost/compressed_pair.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
+# 38 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+template <int BOOST_PP_ITERATION_0>
+inline PyObject* get(mpl::int_<BOOST_PP_ITERATION_0>, PyObject* const& args_)
+{
+    return (((PyTupleObject *)(args_))->ob_item[BOOST_PP_ITERATION_0]);
+}
+
+inline unsigned arity(PyObject* const& args_)
+{
+    return (((PyVarObject*)(args_))->ob_size);
+}
+
+
+
+
+typedef int void_result_to_python;
+
+
+
+
+template <class Policies, class Result>
+struct select_result_converter
+  : mpl::eval_if<
+        is_same<Result,void>
+      , mpl::identity<void_result_to_python>
+      , mpl::apply1<typename Policies::result_converter,Result>
+    >
+{
+};
+
+template <class ArgPackage, class ResultConverter>
+inline ResultConverter create_result_converter(
+    ArgPackage const& args_
+  , ResultConverter*
+  , converter::context_result_converter*
+)
+{
+    return ResultConverter(args_);
+}
+
+template <class ArgPackage, class ResultConverter>
+inline ResultConverter create_result_converter(
+    ArgPackage const&
+  , ResultConverter*
+  , ...
+)
+{
+    return ResultConverter();
+}
+
+
+template <class ResultConverter>
+struct converter_target_type
+{
+    static PyTypeObject const *get_pytype()
+    {
+        return create_result_converter((PyObject*)0, (ResultConverter *)0, (ResultConverter *)0).get_pytype();
+    }
+};
+
+template < >
+struct converter_target_type <void_result_to_python >
+{
+    static PyTypeObject const *get_pytype()
+    {
+        return 0;
+    }
+};
+
+
+
+template <unsigned> struct caller_arity;
+
+template <class F, class CallPolicies, class Sig>
+struct caller;
+# 134 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<0>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+# 215 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+               
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 0; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<1>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 1; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<2>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 2; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<3>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 3; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<4>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 4; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<5>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 5; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<6>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 6; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<7>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 7; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<8>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 8; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<9>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 9; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<10>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 10; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<11>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 11; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<12>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 12; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<13>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 13; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<14>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter12 >::type arg_iter13; typedef arg_from_python<typename arg_iter13::type> c_t13; c_t13 c13(get(mpl::int_<13>(), inner_args)); if (!c13.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12 , c13
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 14; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<15>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter12 >::type arg_iter13; typedef arg_from_python<typename arg_iter13::type> c_t13; c_t13 c13(get(mpl::int_<13>(), inner_args)); if (!c13.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter13 >::type arg_iter14; typedef arg_from_python<typename arg_iter14::type> c_t14; c_t14 c14(get(mpl::int_<14>(), inner_args)); if (!c14.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12 , c13 , c14
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 15; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 188 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <>
+struct caller_arity<16>
+{
+    template <class F, class Policies, class Sig>
+    struct impl
+    {
+        impl(F f, Policies p) : m_data(f,p) {}
+
+        PyObject* operator()(PyObject* args_, PyObject*)
+
+
+
+        {
+            typedef typename mpl::begin<Sig>::type first;
+            typedef typename first::type result_t;
+            typedef typename select_result_converter<Policies, result_t>::type result_converter;
+            typedef typename Policies::argument_package argument_package;
+
+            argument_package inner_args(args_);
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::next<first>::type arg_iter0; typedef arg_from_python<typename arg_iter0::type> c_t0; c_t0 c0(get(mpl::int_<0>(), inner_args)); if (!c0.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter0 >::type arg_iter1; typedef arg_from_python<typename arg_iter1::type> c_t1; c_t1 c1(get(mpl::int_<1>(), inner_args)); if (!c1.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter1 >::type arg_iter2; typedef arg_from_python<typename arg_iter2::type> c_t2; c_t2 c2(get(mpl::int_<2>(), inner_args)); if (!c2.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter2 >::type arg_iter3; typedef arg_from_python<typename arg_iter3::type> c_t3; c_t3 c3(get(mpl::int_<3>(), inner_args)); if (!c3.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter3 >::type arg_iter4; typedef arg_from_python<typename arg_iter4::type> c_t4; c_t4 c4(get(mpl::int_<4>(), inner_args)); if (!c4.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter4 >::type arg_iter5; typedef arg_from_python<typename arg_iter5::type> c_t5; c_t5 c5(get(mpl::int_<5>(), inner_args)); if (!c5.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter5 >::type arg_iter6; typedef arg_from_python<typename arg_iter6::type> c_t6; c_t6 c6(get(mpl::int_<6>(), inner_args)); if (!c6.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter6 >::type arg_iter7; typedef arg_from_python<typename arg_iter7::type> c_t7; c_t7 c7(get(mpl::int_<7>(), inner_args)); if (!c7.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter7 >::type arg_iter8; typedef arg_from_python<typename arg_iter8::type> c_t8; c_t8 c8(get(mpl::int_<8>(), inner_args)); if (!c8.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter8 >::type arg_iter9; typedef arg_from_python<typename arg_iter9::type> c_t9; c_t9 c9(get(mpl::int_<9>(), inner_args)); if (!c9.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter9 >::type arg_iter10; typedef arg_from_python<typename arg_iter10::type> c_t10; c_t10 c10(get(mpl::int_<10>(), inner_args)); if (!c10.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter10 >::type arg_iter11; typedef arg_from_python<typename arg_iter11::type> c_t11; c_t11 c11(get(mpl::int_<11>(), inner_args)); if (!c11.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter11 >::type arg_iter12; typedef arg_from_python<typename arg_iter12::type> c_t12; c_t12 c12(get(mpl::int_<12>(), inner_args)); if (!c12.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter12 >::type arg_iter13; typedef arg_from_python<typename arg_iter13::type> c_t13; c_t13 c13(get(mpl::int_<13>(), inner_args)); if (!c13.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter13 >::type arg_iter14; typedef arg_from_python<typename arg_iter14::type> c_t14; c_t14 c14(get(mpl::int_<14>(), inner_args)); if (!c14.convertible()) return 0;
+
+
+        typedef typename mpl::next< arg_iter14 >::type arg_iter15; typedef arg_from_python<typename arg_iter15::type> c_t15; c_t15 c15(get(mpl::int_<15>(), inner_args)); if (!c15.convertible()) return 0;
+# 212 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+            if (!m_data.second().precall(inner_args))
+                return 0;
+
+            PyObject* result = detail::invoke(
+                detail::invoke_tag<result_t,F>()
+              , create_result_converter(args_, (result_converter*)0, (result_converter*)0)
+              , m_data.first()
+                , c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9 , c10 , c11 , c12 , c13 , c14 , c15
+            );
+
+            return m_data.second().postcall(inner_args, result);
+        }
+
+        static unsigned min_arity() { return 16; }
+
+        static py_func_sig_info signature()
+        {
+            const signature_element * sig = detail::signature<Sig>::elements();
+
+
+            typedef typename Policies::template extract_return_type<Sig>::type rtype;
+            typedef typename select_result_converter<Policies, rtype>::type result_converter;
+
+            static const signature_element ret = {
+                (boost::is_void<rtype>::value ? "void" : type_id<rtype>().name())
+                , &detail::converter_target_type<result_converter>::get_pytype
+                , boost::detail::indirect_traits::is_reference_to_non_const<rtype>::value
+            };
+            py_func_sig_info res = {sig, &ret };
+
+
+
+
+            return res;
+        }
+     private:
+        compressed_pair<F,Policies> m_data;
+    };
+};
+# 128 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 135 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 2
+
+
+
+
+
+
+template <class F, class CallPolicies, class Sig>
+struct caller_base_select
+{
+    enum { arity = mpl::size<Sig>::value - 1 };
+    typedef typename caller_arity<arity>::template impl<F,CallPolicies,Sig> type;
+};
+# 166 "/usr/include/boost-1_42/boost/python/detail/caller.hpp"
+template <class F, class CallPolicies, class Sig>
+struct caller
+    : caller_base_select<F,CallPolicies,Sig>::type
+{
+    typedef typename caller_base_select<
+        F,CallPolicies,Sig
+        >::type base;
+
+    typedef PyObject* result_type;
+
+    caller(F f, CallPolicies p) : base(f,p) {}
+
+};
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/default_call_policies.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/default_call_policies.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/front.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/front.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/front_impl.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/front_impl.hpp"
+namespace boost { namespace mpl {
+
+
+
+
+template< typename Tag >
+struct front_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename begin<Sequence>::type iter_;
+        typedef typename deref<iter_>::type type;
+    };
+};
+
+ template<> struct front_impl<non_sequence_tag> {};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/front.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    >
+struct front
+    : front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+   
+};
+
+template<> struct front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : front< T1 > { }; }; template< typename Tag > struct lambda< front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef front< na > result_; typedef front< na > type; }; namespace aux { template< typename T1 > struct template_arity< front< T1 > > : int_<1> { }; template<> struct template_arity< front< na > > : int_<-1> { }; }
+
+}}
+# 17 "/usr/include/boost-1_42/boost/python/default_call_policies.hpp" 2
+
+namespace boost { namespace python {
+
+template <class T> struct to_python_value;
+
+namespace detail
+{
+
+  template <class T> struct specify_a_return_value_policy_to_wrap_functions_returning
+
+  {}
+
+  ;
+}
+
+struct default_result_converter;
+
+struct default_call_policies
+{
+
+
+    template <class ArgumentPackage>
+    static bool precall(ArgumentPackage const&)
+    {
+        return true;
+    }
+
+
+    template <class ArgumentPackage>
+    static PyObject* postcall(ArgumentPackage const&, PyObject* result)
+    {
+        return result;
+    }
+
+    typedef default_result_converter result_converter;
+    typedef PyObject* argument_package;
+
+    template <class Sig>
+    struct extract_return_type : mpl::front<Sig>
+    {
+    };
+
+};
+
+struct default_result_converter
+{
+    template <class R>
+    struct apply
+    {
+        typedef typename mpl::if_<
+            mpl::or_<is_pointer<R>, is_reference<R> >
+          , detail::specify_a_return_value_policy_to_wrap_functions_returning<R>
+          , boost::python::to_python_value<
+                typename detail::value_arg<R>::type
+            >
+        >::type type;
+    };
+};
+
+
+template <>
+struct default_result_converter::apply<char const*>
+{
+    typedef boost::python::to_python_value<char const*const&> type;
+};
+
+template <>
+struct default_result_converter::apply<PyObject*>
+{
+    typedef boost::python::to_python_value<PyObject*const&> type;
+};
+
+}}
+# 10 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/py_function.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/signature.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/object/py_function.hpp" 2
+
+
+
+
+namespace boost { namespace python { namespace objects {
+
+
+
+
+
+
+struct py_function_impl_base
+{
+    virtual ~py_function_impl_base();
+    virtual PyObject* operator()(PyObject*, PyObject*) = 0;
+    virtual unsigned min_arity() const = 0;
+    virtual unsigned max_arity() const;
+    virtual python::detail::py_func_sig_info signature() const = 0;
+};
+
+template <class Caller>
+struct caller_py_function_impl : py_function_impl_base
+{
+    caller_py_function_impl(Caller const& caller)
+        : m_caller(caller)
+    {}
+
+    PyObject* operator()(PyObject* args, PyObject* kw)
+    {
+        return m_caller(args, kw);
+    }
+
+    virtual unsigned min_arity() const
+    {
+        return m_caller.min_arity();
+    }
+
+    virtual python::detail::py_func_sig_info signature() const
+    {
+        return m_caller.signature();
+    }
+
+ private:
+    Caller m_caller;
+};
+
+template <class Caller, class Sig>
+struct signature_py_function_impl : py_function_impl_base
+{
+    signature_py_function_impl(Caller const& caller)
+        : m_caller(caller)
+    {}
+
+    PyObject* operator()(PyObject* args, PyObject* kw)
+    {
+        return m_caller(args, kw);
+    }
+
+    virtual unsigned min_arity() const
+    {
+        return mpl::size<Sig>::value - 1;
+    }
+
+    virtual python::detail::py_func_sig_info signature() const
+    {
+        python::detail::signature_element const* sig = python::detail::signature<Sig>::elements();
+        python::detail::py_func_sig_info res = {sig, sig};
+        return res;
+    }
+
+ private:
+    Caller m_caller;
+};
+
+template <class Caller, class Sig>
+struct full_py_function_impl : py_function_impl_base
+{
+    full_py_function_impl(Caller const& caller, unsigned min_arity, unsigned max_arity)
+      : m_caller(caller)
+      , m_min_arity(min_arity)
+      , m_max_arity(max_arity > min_arity ? max_arity : min_arity)
+    {}
+
+    PyObject* operator()(PyObject* args, PyObject* kw)
+    {
+        return m_caller(args, kw);
+    }
+
+    virtual unsigned min_arity() const
+    {
+        return m_min_arity;
+    }
+
+    virtual unsigned max_arity() const
+    {
+        return m_max_arity;
+    }
+
+    virtual python::detail::py_func_sig_info signature() const
+    {
+        python::detail::signature_element const* sig = python::detail::signature<Sig>::elements();
+        python::detail::py_func_sig_info res = {sig, sig};
+        return res;
+    }
+
+ private:
+    Caller m_caller;
+    unsigned m_min_arity;
+    unsigned m_max_arity;
+};
+
+struct py_function
+{
+    template <class Caller>
+    py_function(Caller const& caller)
+        : m_impl(new caller_py_function_impl<Caller>(caller))
+    {}
+
+    template <class Caller, class Sig>
+    py_function(Caller const& caller, Sig)
+      : m_impl(new signature_py_function_impl<Caller, Sig>(caller))
+    {}
+
+    template <class Caller, class Sig>
+    py_function(Caller const& caller, Sig, int min_arity, int max_arity = 0)
+      : m_impl(new full_py_function_impl<Caller, Sig>(caller, min_arity, max_arity))
+    {}
+
+    py_function(py_function const& rhs)
+        : m_impl(rhs.m_impl)
+    {}
+
+    PyObject* operator()(PyObject* args, PyObject* kw) const
+    {
+        return (*m_impl)(args, kw);
+    }
+
+    unsigned min_arity() const
+    {
+        return m_impl->min_arity();
+    }
+
+    unsigned max_arity() const
+    {
+        return m_impl->max_arity();
+    }
+
+    python::detail::signature_element const* signature() const
+    {
+        return m_impl->signature().signature;
+    }
+
+    python::detail::signature_element const& get_return_type() const
+    {
+        return *m_impl->signature().ret;
+    }
+
+ private:
+    mutable std::auto_ptr<py_function_impl_base> m_impl;
+};
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/python/signature.hpp"
+namespace boost { namespace python { namespace detail {
+
+
+
+template <class C1, class C2>
+struct most_derived
+{
+    typedef typename mpl::if_<
+        is_convertible<C1*,C2*>
+      , C1
+      , C2
+    >::type type;
+};
+# 106 "/usr/include/boost-1_42/boost/python/signature.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT >
+inline mpl::vector1<
+    RT >
+get_signature(RT(*)(), void* = 0)
+{
+    return mpl::vector1<
+            RT
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT >
+inline mpl::vector2<
+    RT, ClassT& >
+get_signature(RT(ClassT::*)() )
+{
+    return mpl::vector2<
+            RT, ClassT&
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+   
+>
+inline mpl::vector2<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+   
+>
+get_signature(
+    RT(ClassT::*)()
+  , Target*
+)
+{
+    return mpl::vector2<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+       
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT >
+inline mpl::vector2<
+    RT, ClassT& >
+get_signature(RT(ClassT::*)() const)
+{
+    return mpl::vector2<
+            RT, ClassT&
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+   
+>
+inline mpl::vector2<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+   
+>
+get_signature(
+    RT(ClassT::*)() const
+  , Target*
+)
+{
+    return mpl::vector2<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+       
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT >
+inline mpl::vector2<
+    RT, ClassT& >
+get_signature(RT(ClassT::*)() volatile)
+{
+    return mpl::vector2<
+            RT, ClassT&
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+   
+>
+inline mpl::vector2<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+   
+>
+get_signature(
+    RT(ClassT::*)() volatile
+  , Target*
+)
+{
+    return mpl::vector2<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+       
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT >
+inline mpl::vector2<
+    RT, ClassT& >
+get_signature(RT(ClassT::*)() const volatile)
+{
+    return mpl::vector2<
+            RT, ClassT&
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+   
+>
+inline mpl::vector2<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+   
+>
+get_signature(
+    RT(ClassT::*)() const volatile
+  , Target*
+)
+{
+    return mpl::vector2<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+       
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0>
+inline mpl::vector2<
+    RT , T0>
+get_signature(RT(*)( T0), void* = 0)
+{
+    return mpl::vector2<
+            RT , T0
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0>
+inline mpl::vector3<
+    RT, ClassT& , T0>
+get_signature(RT(ClassT::*)( T0) )
+{
+    return mpl::vector3<
+            RT, ClassT& , T0
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0
+>
+inline mpl::vector3<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0
+>
+get_signature(
+    RT(ClassT::*)( T0)
+  , Target*
+)
+{
+    return mpl::vector3<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0>
+inline mpl::vector3<
+    RT, ClassT& , T0>
+get_signature(RT(ClassT::*)( T0) const)
+{
+    return mpl::vector3<
+            RT, ClassT& , T0
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0
+>
+inline mpl::vector3<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0
+>
+get_signature(
+    RT(ClassT::*)( T0) const
+  , Target*
+)
+{
+    return mpl::vector3<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0>
+inline mpl::vector3<
+    RT, ClassT& , T0>
+get_signature(RT(ClassT::*)( T0) volatile)
+{
+    return mpl::vector3<
+            RT, ClassT& , T0
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0
+>
+inline mpl::vector3<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0
+>
+get_signature(
+    RT(ClassT::*)( T0) volatile
+  , Target*
+)
+{
+    return mpl::vector3<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0>
+inline mpl::vector3<
+    RT, ClassT& , T0>
+get_signature(RT(ClassT::*)( T0) const volatile)
+{
+    return mpl::vector3<
+            RT, ClassT& , T0
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0
+>
+inline mpl::vector3<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0
+>
+get_signature(
+    RT(ClassT::*)( T0) const volatile
+  , Target*
+)
+{
+    return mpl::vector3<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1>
+inline mpl::vector3<
+    RT , T0 , T1>
+get_signature(RT(*)( T0 , T1), void* = 0)
+{
+    return mpl::vector3<
+            RT , T0 , T1
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1>
+inline mpl::vector4<
+    RT, ClassT& , T0 , T1>
+get_signature(RT(ClassT::*)( T0 , T1) )
+{
+    return mpl::vector4<
+            RT, ClassT& , T0 , T1
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1
+>
+inline mpl::vector4<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1)
+  , Target*
+)
+{
+    return mpl::vector4<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1>
+inline mpl::vector4<
+    RT, ClassT& , T0 , T1>
+get_signature(RT(ClassT::*)( T0 , T1) const)
+{
+    return mpl::vector4<
+            RT, ClassT& , T0 , T1
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1
+>
+inline mpl::vector4<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1) const
+  , Target*
+)
+{
+    return mpl::vector4<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1>
+inline mpl::vector4<
+    RT, ClassT& , T0 , T1>
+get_signature(RT(ClassT::*)( T0 , T1) volatile)
+{
+    return mpl::vector4<
+            RT, ClassT& , T0 , T1
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1
+>
+inline mpl::vector4<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1) volatile
+  , Target*
+)
+{
+    return mpl::vector4<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1>
+inline mpl::vector4<
+    RT, ClassT& , T0 , T1>
+get_signature(RT(ClassT::*)( T0 , T1) const volatile)
+{
+    return mpl::vector4<
+            RT, ClassT& , T0 , T1
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1
+>
+inline mpl::vector4<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1) const volatile
+  , Target*
+)
+{
+    return mpl::vector4<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2>
+inline mpl::vector4<
+    RT , T0 , T1 , T2>
+get_signature(RT(*)( T0 , T1 , T2), void* = 0)
+{
+    return mpl::vector4<
+            RT , T0 , T1 , T2
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2>
+inline mpl::vector5<
+    RT, ClassT& , T0 , T1 , T2>
+get_signature(RT(ClassT::*)( T0 , T1 , T2) )
+{
+    return mpl::vector5<
+            RT, ClassT& , T0 , T1 , T2
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2
+>
+inline mpl::vector5<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2)
+  , Target*
+)
+{
+    return mpl::vector5<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2>
+inline mpl::vector5<
+    RT, ClassT& , T0 , T1 , T2>
+get_signature(RT(ClassT::*)( T0 , T1 , T2) const)
+{
+    return mpl::vector5<
+            RT, ClassT& , T0 , T1 , T2
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2
+>
+inline mpl::vector5<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2) const
+  , Target*
+)
+{
+    return mpl::vector5<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2>
+inline mpl::vector5<
+    RT, ClassT& , T0 , T1 , T2>
+get_signature(RT(ClassT::*)( T0 , T1 , T2) volatile)
+{
+    return mpl::vector5<
+            RT, ClassT& , T0 , T1 , T2
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2
+>
+inline mpl::vector5<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2) volatile
+  , Target*
+)
+{
+    return mpl::vector5<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2>
+inline mpl::vector5<
+    RT, ClassT& , T0 , T1 , T2>
+get_signature(RT(ClassT::*)( T0 , T1 , T2) const volatile)
+{
+    return mpl::vector5<
+            RT, ClassT& , T0 , T1 , T2
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2
+>
+inline mpl::vector5<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2) const volatile
+  , Target*
+)
+{
+    return mpl::vector5<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3>
+inline mpl::vector5<
+    RT , T0 , T1 , T2 , T3>
+get_signature(RT(*)( T0 , T1 , T2 , T3), void* = 0)
+{
+    return mpl::vector5<
+            RT , T0 , T1 , T2 , T3
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
+inline mpl::vector6<
+    RT, ClassT& , T0 , T1 , T2 , T3>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) )
+{
+    return mpl::vector6<
+            RT, ClassT& , T0 , T1 , T2 , T3
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3
+>
+inline mpl::vector6<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3)
+  , Target*
+)
+{
+    return mpl::vector6<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
+inline mpl::vector6<
+    RT, ClassT& , T0 , T1 , T2 , T3>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) const)
+{
+    return mpl::vector6<
+            RT, ClassT& , T0 , T1 , T2 , T3
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3
+>
+inline mpl::vector6<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3) const
+  , Target*
+)
+{
+    return mpl::vector6<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
+inline mpl::vector6<
+    RT, ClassT& , T0 , T1 , T2 , T3>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) volatile)
+{
+    return mpl::vector6<
+            RT, ClassT& , T0 , T1 , T2 , T3
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3
+>
+inline mpl::vector6<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3) volatile
+  , Target*
+)
+{
+    return mpl::vector6<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3>
+inline mpl::vector6<
+    RT, ClassT& , T0 , T1 , T2 , T3>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3) const volatile)
+{
+    return mpl::vector6<
+            RT, ClassT& , T0 , T1 , T2 , T3
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3
+>
+inline mpl::vector6<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3) const volatile
+  , Target*
+)
+{
+    return mpl::vector6<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4>
+inline mpl::vector6<
+    RT , T0 , T1 , T2 , T3 , T4>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4), void* = 0)
+{
+    return mpl::vector6<
+            RT , T0 , T1 , T2 , T3 , T4
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
+inline mpl::vector7<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) )
+{
+    return mpl::vector7<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4
+>
+inline mpl::vector7<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4)
+  , Target*
+)
+{
+    return mpl::vector7<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
+inline mpl::vector7<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const)
+{
+    return mpl::vector7<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4
+>
+inline mpl::vector7<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const
+  , Target*
+)
+{
+    return mpl::vector7<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
+inline mpl::vector7<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) volatile)
+{
+    return mpl::vector7<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4
+>
+inline mpl::vector7<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) volatile
+  , Target*
+)
+{
+    return mpl::vector7<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4>
+inline mpl::vector7<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const volatile)
+{
+    return mpl::vector7<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4
+>
+inline mpl::vector7<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4) const volatile
+  , Target*
+)
+{
+    return mpl::vector7<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+inline mpl::vector7<
+    RT , T0 , T1 , T2 , T3 , T4 , T5>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5), void* = 0)
+{
+    return mpl::vector7<
+            RT , T0 , T1 , T2 , T3 , T4 , T5
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+inline mpl::vector8<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) )
+{
+    return mpl::vector8<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
+>
+inline mpl::vector8<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5)
+  , Target*
+)
+{
+    return mpl::vector8<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+inline mpl::vector8<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const)
+{
+    return mpl::vector8<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
+>
+inline mpl::vector8<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const
+  , Target*
+)
+{
+    return mpl::vector8<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+inline mpl::vector8<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile)
+{
+    return mpl::vector8<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
+>
+inline mpl::vector8<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) volatile
+  , Target*
+)
+{
+    return mpl::vector8<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5>
+inline mpl::vector8<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile)
+{
+    return mpl::vector8<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5
+>
+inline mpl::vector8<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5) const volatile
+  , Target*
+)
+{
+    return mpl::vector8<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+inline mpl::vector8<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6), void* = 0)
+{
+    return mpl::vector8<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+inline mpl::vector9<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) )
+{
+    return mpl::vector9<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
+>
+inline mpl::vector9<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6)
+  , Target*
+)
+{
+    return mpl::vector9<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+inline mpl::vector9<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const)
+{
+    return mpl::vector9<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
+>
+inline mpl::vector9<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const
+  , Target*
+)
+{
+    return mpl::vector9<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+inline mpl::vector9<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile)
+{
+    return mpl::vector9<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
+>
+inline mpl::vector9<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) volatile
+  , Target*
+)
+{
+    return mpl::vector9<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6>
+inline mpl::vector9<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile)
+{
+    return mpl::vector9<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6
+>
+inline mpl::vector9<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6) const volatile
+  , Target*
+)
+{
+    return mpl::vector9<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+inline mpl::vector9<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7), void* = 0)
+{
+    return mpl::vector9<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+inline mpl::vector10<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) )
+{
+    return mpl::vector10<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
+>
+inline mpl::vector10<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7)
+  , Target*
+)
+{
+    return mpl::vector10<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+inline mpl::vector10<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const)
+{
+    return mpl::vector10<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
+>
+inline mpl::vector10<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const
+  , Target*
+)
+{
+    return mpl::vector10<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+inline mpl::vector10<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile)
+{
+    return mpl::vector10<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
+>
+inline mpl::vector10<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) volatile
+  , Target*
+)
+{
+    return mpl::vector10<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7>
+inline mpl::vector10<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile)
+{
+    return mpl::vector10<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7
+>
+inline mpl::vector10<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7) const volatile
+  , Target*
+)
+{
+    return mpl::vector10<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+inline mpl::vector10<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8), void* = 0)
+{
+    return mpl::vector10<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+inline mpl::vector11<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) )
+{
+    return mpl::vector11<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
+>
+inline mpl::vector11<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8)
+  , Target*
+)
+{
+    return mpl::vector11<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+inline mpl::vector11<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const)
+{
+    return mpl::vector11<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
+>
+inline mpl::vector11<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const
+  , Target*
+)
+{
+    return mpl::vector11<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+inline mpl::vector11<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile)
+{
+    return mpl::vector11<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
+>
+inline mpl::vector11<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) volatile
+  , Target*
+)
+{
+    return mpl::vector11<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8>
+inline mpl::vector11<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile)
+{
+    return mpl::vector11<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8
+>
+inline mpl::vector11<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8) const volatile
+  , Target*
+)
+{
+    return mpl::vector11<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+inline mpl::vector11<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9), void* = 0)
+{
+    return mpl::vector11<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+inline mpl::vector12<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) )
+{
+    return mpl::vector12<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
+>
+inline mpl::vector12<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9)
+  , Target*
+)
+{
+    return mpl::vector12<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+inline mpl::vector12<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const)
+{
+    return mpl::vector12<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
+>
+inline mpl::vector12<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const
+  , Target*
+)
+{
+    return mpl::vector12<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+inline mpl::vector12<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile)
+{
+    return mpl::vector12<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
+>
+inline mpl::vector12<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) volatile
+  , Target*
+)
+{
+    return mpl::vector12<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9>
+inline mpl::vector12<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile)
+{
+    return mpl::vector12<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9
+>
+inline mpl::vector12<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9) const volatile
+  , Target*
+)
+{
+    return mpl::vector12<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+inline mpl::vector12<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10), void* = 0)
+{
+    return mpl::vector12<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+inline mpl::vector13<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) )
+{
+    return mpl::vector13<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
+>
+inline mpl::vector13<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10)
+  , Target*
+)
+{
+    return mpl::vector13<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+inline mpl::vector13<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const)
+{
+    return mpl::vector13<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
+>
+inline mpl::vector13<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const
+  , Target*
+)
+{
+    return mpl::vector13<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+inline mpl::vector13<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile)
+{
+    return mpl::vector13<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
+>
+inline mpl::vector13<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) volatile
+  , Target*
+)
+{
+    return mpl::vector13<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10>
+inline mpl::vector13<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile)
+{
+    return mpl::vector13<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10
+>
+inline mpl::vector13<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10) const volatile
+  , Target*
+)
+{
+    return mpl::vector13<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+inline mpl::vector13<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11), void* = 0)
+{
+    return mpl::vector13<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+inline mpl::vector14<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) )
+{
+    return mpl::vector14<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
+>
+inline mpl::vector14<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11)
+  , Target*
+)
+{
+    return mpl::vector14<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+inline mpl::vector14<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const)
+{
+    return mpl::vector14<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
+>
+inline mpl::vector14<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const
+  , Target*
+)
+{
+    return mpl::vector14<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+inline mpl::vector14<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile)
+{
+    return mpl::vector14<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
+>
+inline mpl::vector14<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) volatile
+  , Target*
+)
+{
+    return mpl::vector14<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11>
+inline mpl::vector14<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile)
+{
+    return mpl::vector14<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11
+>
+inline mpl::vector14<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11) const volatile
+  , Target*
+)
+{
+    return mpl::vector14<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+inline mpl::vector14<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12), void* = 0)
+{
+    return mpl::vector14<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+inline mpl::vector15<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) )
+{
+    return mpl::vector15<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
+>
+inline mpl::vector15<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12)
+  , Target*
+)
+{
+    return mpl::vector15<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+inline mpl::vector15<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const)
+{
+    return mpl::vector15<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
+>
+inline mpl::vector15<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const
+  , Target*
+)
+{
+    return mpl::vector15<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+inline mpl::vector15<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile)
+{
+    return mpl::vector15<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
+>
+inline mpl::vector15<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) volatile
+  , Target*
+)
+{
+    return mpl::vector15<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12>
+inline mpl::vector15<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile)
+{
+    return mpl::vector15<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12
+>
+inline mpl::vector15<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12) const volatile
+  , Target*
+)
+{
+    return mpl::vector15<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+inline mpl::vector15<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13), void* = 0)
+{
+    return mpl::vector15<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+inline mpl::vector16<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) )
+{
+    return mpl::vector16<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
+>
+inline mpl::vector16<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13)
+  , Target*
+)
+{
+    return mpl::vector16<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+inline mpl::vector16<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const)
+{
+    return mpl::vector16<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
+>
+inline mpl::vector16<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const
+  , Target*
+)
+{
+    return mpl::vector16<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+inline mpl::vector16<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile)
+{
+    return mpl::vector16<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
+>
+inline mpl::vector16<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) volatile
+  , Target*
+)
+{
+    return mpl::vector16<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13>
+inline mpl::vector16<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile)
+{
+    return mpl::vector16<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13
+>
+inline mpl::vector16<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13) const volatile
+  , Target*
+)
+{
+    return mpl::vector16<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+inline mpl::vector16<
+    RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
+get_signature(RT(*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14), void* = 0)
+{
+    return mpl::vector16<
+            RT , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+        >();
+}
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+inline mpl::vector17<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) )
+{
+    return mpl::vector17<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
+>
+inline mpl::vector17<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14)
+  , Target*
+)
+{
+    return mpl::vector17<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+    >();
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+inline mpl::vector17<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const)
+{
+    return mpl::vector17<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
+>
+inline mpl::vector17<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const
+  , Target*
+)
+{
+    return mpl::vector17<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+    >();
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+inline mpl::vector17<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile)
+{
+    return mpl::vector17<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
+>
+inline mpl::vector17<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) volatile
+  , Target*
+)
+{
+    return mpl::vector17<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+    >();
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 145 "/usr/include/boost-1_42/boost/python/signature.hpp"
+template <
+    class RT, class ClassT , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+inline mpl::vector17<
+    RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
+get_signature(RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile)
+{
+    return mpl::vector17<
+            RT, ClassT& , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+        >();
+}
+
+template <
+    class Target
+  , class RT
+  , class ClassT
+    , class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14
+>
+inline mpl::vector17<
+    RT
+  , typename most_derived<Target, ClassT>::type&
+    , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+>
+get_signature(
+    RT(ClassT::*)( T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14) const volatile
+  , Target*
+)
+{
+    return mpl::vector17<
+        RT
+      , typename most_derived<Target, ClassT>::type&
+        , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14
+    >();
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 139 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 107 "/usr/include/boost-1_42/boost/python/signature.hpp" 2
+
+
+
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/object/function_handle.hpp" 2
+
+namespace boost { namespace python { namespace objects {
+
+ handle<> function_handle_impl(py_function const& f);
+
+
+
+
+template <class F, class Signature>
+inline handle<> function_handle(F const& f, Signature)
+{
+    enum { n_arguments = mpl::size<Signature>::value - 1 };
+
+    return objects::function_handle_impl(
+        python::detail::caller<
+            F,default_call_policies,Signature
+        >(
+            f, default_call_policies()
+         )
+    );
+}
+
+
+
+template <class F>
+handle<> make_function_handle(F f)
+{
+    return objects::function_handle(f, python::detail::get_signature(f));
+}
+
+}}}
+# 20 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 9 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/array_traits.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp" 2
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+
+template <class T>
+struct is_string_literal : mpl::false_
+{
+};
+
+
+template <std::size_t n>
+struct is_string_literal<char const[n]> : mpl::true_
+{
+};
+# 86 "/usr/include/boost-1_42/boost/python/detail/string_literal.hpp"
+}}}
+# 26 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/function_traits.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/type_traits/function_traits.hpp"
+namespace boost {
+
+
+namespace detail {
+
+template<typename Function> struct function_traits_helper;
+
+template<typename R>
+struct function_traits_helper<R (*)(void)>
+{
+  static const unsigned arity = 0;
+  typedef R result_type;
+};
+
+template<typename R, typename T1>
+struct function_traits_helper<R (*)(T1)>
+{
+  static const unsigned arity = 1;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T1 argument_type;
+};
+
+template<typename R, typename T1, typename T2>
+struct function_traits_helper<R (*)(T1, T2)>
+{
+  static const unsigned arity = 2;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T1 first_argument_type;
+  typedef T2 second_argument_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3>
+struct function_traits_helper<R (*)(T1, T2, T3)>
+{
+  static const unsigned arity = 3;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4>
+struct function_traits_helper<R (*)(T1, T2, T3, T4)>
+{
+  static const unsigned arity = 4;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
+{
+  static const unsigned arity = 5;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
+{
+  static const unsigned arity = 6;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
+{
+  static const unsigned arity = 7;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
+{
+  static const unsigned arity = 8;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
+{
+  static const unsigned arity = 9;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+};
+
+template<typename R, typename T1, typename T2, typename T3, typename T4,
+         typename T5, typename T6, typename T7, typename T8, typename T9,
+         typename T10>
+struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
+{
+  static const unsigned arity = 10;
+  typedef R result_type;
+  typedef T1 arg1_type;
+  typedef T2 arg2_type;
+  typedef T3 arg3_type;
+  typedef T4 arg4_type;
+  typedef T5 arg5_type;
+  typedef T6 arg6_type;
+  typedef T7 arg7_type;
+  typedef T8 arg8_type;
+  typedef T9 arg9_type;
+  typedef T10 arg10_type;
+};
+
+}
+
+template<typename Function>
+struct function_traits :
+   public detail::function_traits_helper<typename boost::add_pointer<Function>::type>
+{
+};
+# 234 "/usr/include/boost-1_42/boost/type_traits/function_traits.hpp"
+}
+# 31 "/usr/include/boost-1_42/boost/python/converter/arg_to_python.hpp" 2
+
+
+
+
+namespace boost { namespace python { namespace converter {
+
+template <class T> struct is_object_manager;
+
+namespace detail
+{
+  template <class T>
+  struct function_arg_to_python : handle<>
+  {
+      function_arg_to_python(T const& x);
+  };
+
+  template <class T>
+  struct reference_arg_to_python : handle<>
+  {
+      reference_arg_to_python(T& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct shared_ptr_arg_to_python : handle<>
+  {
+      shared_ptr_arg_to_python(T const& x);
+   private:
+      static PyObject* get_object(T& x);
+  };
+
+  template <class T>
+  struct value_arg_to_python : arg_to_python_base
+  {
+
+      value_arg_to_python(T const&);
+  };
+
+  template <class Ptr>
+  struct pointer_deep_arg_to_python : arg_to_python_base
+  {
+
+      pointer_deep_arg_to_python(Ptr);
+  };
+
+  template <class Ptr>
+  struct pointer_shallow_arg_to_python : handle<>
+  {
+
+      pointer_shallow_arg_to_python(Ptr);
+   private:
+      static PyObject* get_object(Ptr p);
+  };
+
+
+  template <class T>
+  struct object_manager_arg_to_python
+  {
+      object_manager_arg_to_python(T const& x) : m_src(x) {}
+
+      PyObject* get() const
+      {
+          return python::upcast<PyObject>(get_managed_object(m_src, tag));
+      }
+
+   private:
+      T const& m_src;
+  };
+
+  template <class T>
+  struct select_arg_to_python
+  {
+      typedef typename unwrap_reference<T>::type unwrapped_referent;
+      typedef typename unwrap_pointer<T>::type unwrapped_ptr;
+
+      typedef typename mpl::if_<
+
+
+          python::detail::is_string_literal<T const>
+        , arg_to_python<char const*>
+
+        , typename mpl::if_<
+              python::detail::value_is_shared_ptr<T>
+            , shared_ptr_arg_to_python<T>
+
+            , typename mpl::if_<
+                mpl::or_<
+                    is_function<T>
+                  , indirect_traits::is_pointer_to_function<T>
+                  , is_member_function_pointer<T>
+                >
+                , function_arg_to_python<T>
+
+                , typename mpl::if_<
+                      is_object_manager<T>
+                    , object_manager_arg_to_python<T>
+
+                    , typename mpl::if_<
+                          is_pointer<T>
+                        , pointer_deep_arg_to_python<T>
+
+                        , typename mpl::if_<
+                              is_pointer_wrapper<T>
+                            , pointer_shallow_arg_to_python<unwrapped_ptr>
+
+                            , typename mpl::if_<
+                                  is_reference_wrapper<T>
+                                , reference_arg_to_python<unwrapped_referent>
+                                , value_arg_to_python<T>
+                              >::type
+                          >::type
+                      >::type
+                  >::type
+              >::type
+          >::type
+      >::type
+
+      type;
+  };
+}
+
+template <class T>
+struct arg_to_python
+    : detail::select_arg_to_python<T>::type
+{
+    typedef typename detail::select_arg_to_python<T>::type base;
+ public:
+
+    arg_to_python(T const& x);
+};
+
+
+
+
+namespace detail
+{
+
+
+  using python::detail::yes_convertible;
+  using python::detail::no_convertible;
+  using python::detail::unspecialized;
+
+  template <class T> struct cannot_convert_raw_PyObject;
+
+  template <class T, class Convertibility>
+  struct reject_raw_object_helper
+  {
+      static void error(Convertibility)
+      {
+          cannot_convert_raw_PyObject<T*>::to_python_use_handle_instead();
+      }
+      static void error(...) {}
+  };
+
+  template <class T>
+  inline void reject_raw_object_ptr(T*)
+  {
+      reject_raw_object_helper<T,yes_convertible>::error(
+          python::detail::convertible<PyObject const volatile*>::check((T*)0));
+
+      typedef typename remove_cv<T>::type value_type;
+
+      reject_raw_object_helper<T,no_convertible>::error(
+          python::detail::convertible<unspecialized*>::check(
+              (base_type_traits<value_type>*)0
+              ));
+  }
+
+
+  template <class T>
+  inline function_arg_to_python<T>::function_arg_to_python(T const& x)
+      : handle<>(python::objects::make_function_handle(x))
+  {
+  }
+
+  template <class T>
+  inline value_arg_to_python<T>::value_arg_to_python(T const& x)
+      : arg_to_python_base(&x, registered<T>::converters)
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_deep_arg_to_python<Ptr>::pointer_deep_arg_to_python(Ptr x)
+      : arg_to_python_base(x, registered_pointee<Ptr>::converters)
+  {
+      detail::reject_raw_object_ptr((Ptr)0);
+  }
+
+  template <class T>
+  inline PyObject* reference_arg_to_python<T>::get_object(T& x)
+  {
+      to_python_indirect<T&,python::detail::make_reference_holder> convert;
+      return convert(x);
+  }
+
+  template <class T>
+  inline reference_arg_to_python<T>::reference_arg_to_python(T& x)
+      : handle<>(reference_arg_to_python<T>::get_object(x))
+  {
+  }
+
+  template <class T>
+  inline shared_ptr_arg_to_python<T>::shared_ptr_arg_to_python(T const& x)
+      : handle<>(shared_ptr_to_python(x))
+  {
+  }
+
+  template <class Ptr>
+  inline pointer_shallow_arg_to_python<Ptr>::pointer_shallow_arg_to_python(Ptr x)
+      : handle<>(pointer_shallow_arg_to_python<Ptr>::get_object(x))
+  {
+      detail::reject_raw_object_ptr((Ptr)0);
+  }
+
+  template <class Ptr>
+  inline PyObject* pointer_shallow_arg_to_python<Ptr>::get_object(Ptr x)
+  {
+      to_python_indirect<Ptr,python::detail::make_reference_holder> convert;
+      return convert(x);
+  }
+}
+
+template <class T>
+inline arg_to_python<T>::arg_to_python(T const& x)
+    : base(x)
+{}
+
+}}}
+# 16 "/usr/include/boost-1_42/boost/python/call.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/converter/return_from_python.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/converter/return_from_python.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/void_return.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/detail/void_return.hpp"
+namespace boost { namespace python { namespace detail {
+
+struct void_return
+{
+    void_return() {}
+ private:
+    void operator=(void_return const&);
+};
+
+template <class T>
+struct returnable
+{
+    typedef T type;
+};
+# 40 "/usr/include/boost-1_42/boost/python/detail/void_return.hpp"
+}}}
+# 15 "/usr/include/boost-1_42/boost/python/converter/return_from_python.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace python { namespace converter {
+
+template <class T> struct is_object_manager;
+
+namespace detail
+{
+  template <class T>
+  struct return_pointer_from_python
+  {
+      typedef T result_type;
+      T operator()(PyObject*) const;
+  };
+
+  template <class T>
+  struct return_reference_from_python
+  {
+      typedef T result_type;
+      T operator()(PyObject*) const;
+  };
+
+  template <class T>
+  struct return_rvalue_from_python
+  {
+      typedef T result_type;
+
+      return_rvalue_from_python();
+      result_type operator()(PyObject*);
+   private:
+      rvalue_from_python_data<T> m_data;
+  };
+
+  template <class T>
+  struct return_object_manager_from_python
+  {
+      typedef T result_type;
+      result_type operator()(PyObject*) const;
+  };
+
+  template <class T>
+  struct select_return_from_python
+  {
+      static const bool obj_mgr = is_object_manager<T>::value
+                                                      ;
+
+      static const bool ptr = is_pointer<T>::value
+                                           ;
+
+      static const bool ref = is_reference<T>::value
+                                             ;
+
+      typedef typename mpl::if_c<
+          obj_mgr
+          , return_object_manager_from_python<T>
+          , typename mpl::if_c<
+              ptr
+              , return_pointer_from_python<T>
+              , typename mpl::if_c<
+                  ref
+                  , return_reference_from_python<T>
+                  , return_rvalue_from_python<T>
+                >::type
+            >::type
+         >::type type;
+  };
+}
+
+template <class T>
+struct return_from_python
+    : detail::select_return_from_python<T>::type
+{
+};
+
+
+template <>
+struct return_from_python<void>
+{
+    typedef python::detail::returnable<void>::type result_type;
+
+    result_type operator()(PyObject* x) const
+    {
+        (void_result_from_python)(x);
+
+
+
+    }
+};
+
+
+
+
+namespace detail
+{
+  template <class T>
+  inline return_rvalue_from_python<T>::return_rvalue_from_python()
+      : m_data(
+          const_cast<registration*>(&registered<T>::converters)
+          )
+  {
+  }
+
+  template <class T>
+  inline typename return_rvalue_from_python<T>::result_type
+  return_rvalue_from_python<T>::operator()(PyObject* obj)
+  {
+
+
+
+
+    handle<> holder(obj);
+
+      return *(T*)
+          (rvalue_result_from_python)(obj, m_data.stage1);
+  }
+
+  template <class T>
+  inline T return_reference_from_python<T>::operator()(PyObject* obj) const
+  {
+      return python::detail::void_ptr_to_reference(
+          (reference_result_from_python)(obj, registered<T>::converters)
+          , (T(*)())0);
+  }
+
+  template <class T>
+  inline T return_pointer_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(
+          (pointer_result_from_python)(obj, registered_pointee<T>::converters)
+          );
+  }
+
+  template <class T>
+  inline T return_object_manager_from_python<T>::operator()(PyObject* obj) const
+  {
+      return T(
+          object_manager_traits<T>::adopt(expect_non_null(obj))
+          );
+  }
+}
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/call.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/python/call.hpp"
+namespace boost { namespace python {
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+   
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+   
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" ")")
+           
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" ")")
+            , converter::arg_to_python<A0>(a0).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/python/call.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14
+    >
+typename detail::returnable<R>::type
+call(PyObject* callable
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallFunction(
+            callable
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get() , converter::arg_to_python<A14>(a14).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 34 "/usr/include/boost-1_42/boost/python/call.hpp" 2
+
+
+
+}}
+# 13 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/def_visitor.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/def_visitor.hpp"
+namespace boost { namespace python {
+
+template <class DerivedVisitor> class def_visitor;
+template <class T, class X1, class X2, class X3> class class_;
+
+class def_visitor_access
+{
+
+
+
+
+
+
+    template <class Derived> friend class def_visitor;
+
+
+
+    template <class V, class classT>
+    static void visit(V const& v, classT& c)
+    {
+        v.derived_visitor().visit(c);
+    }
+
+
+    template <class V, class classT, class OptionalArgs>
+    static void visit(
+        V const& v
+      , classT& c
+      , char const* name
+      , OptionalArgs const& options
+    )
+    {
+        v.derived_visitor().visit(c, name, options);
+    }
+
+};
+
+
+template <class DerivedVisitor>
+class def_visitor
+{
+    friend class def_visitor_access;
+
+
+
+
+
+
+
+    template <class T, class X1, class X2, class X3> friend class class_;
+
+
+
+    template <class classT>
+    void visit(classT& c) const
+    {
+        def_visitor_access::visit(*this, c);
+    }
+
+
+    template <class classT, class OptionalArgs>
+    void visit(classT& c, char const* name, OptionalArgs const& options) const
+    {
+        def_visitor_access::visit(*this, c, name, options);
+    }
+
+ protected:
+    DerivedVisitor const& derived_visitor() const
+    {
+        return static_cast<DerivedVisitor const&>(*this);
+    }
+};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/add_to_namespace.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object/add_to_namespace.hpp"
+namespace boost { namespace python { namespace objects {
+
+
+
+
+ void add_to_namespace(
+    object const& name_space, char const* name, object const& attribute);
+
+ void add_to_namespace(
+    object const& name_space, char const* name, object const& attribute, char const* doc);
+
+}}}
+# 25 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/def_helper_fwd.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/not_specified.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+  struct not_specified {};
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/detail/def_helper_fwd.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+template <class T1, class T2 = not_specified, class T3 = not_specified, class T4 = not_specified>
+struct def_helper;
+
+}}}
+# 32 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  class kwds_proxy;
+  class args_proxy;
+}
+
+namespace converter
+{
+  template <class T> struct arg_to_python;
+}
+
+
+namespace api
+{
+
+
+
+
+
+  template <class Policies> class proxy;
+
+  struct const_attribute_policies;
+  struct attribute_policies;
+  struct const_objattribute_policies;
+  struct objattribute_policies;
+  struct const_item_policies;
+  struct item_policies;
+  struct const_slice_policies;
+  struct slice_policies;
+  class slice_nil;
+
+  typedef proxy<const_attribute_policies> const_object_attribute;
+  typedef proxy<attribute_policies> object_attribute;
+  typedef proxy<const_objattribute_policies> const_object_objattribute;
+  typedef proxy<objattribute_policies> object_objattribute;
+  typedef proxy<const_item_policies> const_object_item;
+  typedef proxy<item_policies> object_item;
+  typedef proxy<const_slice_policies> const_object_slice;
+  typedef proxy<slice_policies> object_slice;
+
+
+
+
+  template <class T> struct is_proxy : mpl::false_ { }; template < class T0 > struct is_proxy< boost::python::api::proxy< T0 > > : mpl::true_ { };
+
+  template <class T> struct object_initializer;
+
+  class object;
+  typedef PyObject* (object::*bool_type)() const;
+
+  template <class U>
+  class object_operators : public def_visitor<U>
+  {
+   protected:
+
+      typedef object const& object_cref;
+
+
+
+   public:
+
+
+      object operator()() const;
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 52 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0);
+    }
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1);
+    }
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2);
+    }
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3);
+    }
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4);
+    }
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5);
+    }
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6);
+    }
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+    }
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+    }
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+    }
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10);
+    }
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11);
+    }
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12);
+    }
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13);
+    }
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object_call.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object_call.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+    typename detail::dependent<object, A0>::type
+    operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14) const
+    {
+        typedef typename detail::dependent<object, A0>::type obj;
+        U const& self = *static_cast<U const*>(this);
+        return call<obj>(get_managed_object(self, tag), a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9 , a10 , a11 , a12 , a13 , a14);
+    }
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 111 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
+
+      detail::args_proxy operator* () const;
+      object operator()(detail::args_proxy const &args) const;
+      object operator()(detail::args_proxy const &args,
+                        detail::kwds_proxy const &kwds) const;
+
+
+
+      operator bool_type() const;
+      bool operator!() const;
+
+
+
+      const_object_attribute attr(char const*) const;
+      object_attribute attr(char const*);
+      const_object_objattribute attr(object const&) const;
+      object_objattribute attr(object const&);
+
+
+      template <class T>
+      object contains(T const& key) const;
+
+
+
+      const_object_item operator[](object_cref) const;
+      object_item operator[](object_cref);
+
+      template <class T>
+      const_object_item
+      operator[](T const& key) const
+
+          ;
+
+
+
+
+
+
+      template <class T>
+      object_item
+      operator[](T const& key)
+
+          ;
+# 162 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+      const_object_slice slice(object_cref, object_cref) const;
+      object_slice slice(object_cref, object_cref);
+
+      const_object_slice slice(slice_nil, object_cref) const;
+      object_slice slice(slice_nil, object_cref);
+
+      const_object_slice slice(object_cref, slice_nil) const;
+      object_slice slice(object_cref, slice_nil);
+
+      const_object_slice slice(slice_nil, slice_nil) const;
+      object_slice slice(slice_nil, slice_nil);
+
+      template <class T, class V>
+      const_object_slice
+      slice(T const& start, V const& end) const
+
+          ;
+# 187 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+      template <class T, class V>
+      object_slice
+      slice(T const& start, V const& end)
+
+          ;
+# 200 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+   private:
+
+      template <class ClassT, class DocStringT>
+      void visit(ClassT& cl, char const* name, python::detail::def_helper<DocStringT> const& helper) const
+      {
+
+
+          typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_same<char const*,DocStringT>::value || detail::is_string_literal<DocStringT const>::value)) == 0 ? false : true) >)>
+
+ boost_static_assert_typedef_209;
+
+          objects::add_to_namespace(cl, name, this->derived_visitor(), helper.doc());
+      }
+
+      friend class python::def_visitor_access;
+
+   private:
+
+
+
+
+    typedef object const& object_cref2;
+
+
+
+  };
+
+
+
+
+
+  struct object_base : object_operators<object>
+  {
+
+      inline object_base(object_base const&);
+      inline object_base(PyObject* ptr);
+
+      inline object_base& operator=(object_base const& rhs);
+      inline ~object_base();
+
+
+      inline PyObject* ptr() const;
+
+   private:
+      PyObject* m_ptr;
+  };
+# 267 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+  template <class T, class U>
+  struct is_derived
+    : is_convertible<
+          typename remove_reference<T>::type*
+        , U const*
+      >
+  {};
+
+
+  template <class T>
+  typename objects::unforward_cref<T>::type do_unforward_cref(T const& x)
+  {
+
+
+
+
+      return x;
+
+  }
+# 296 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+  class object;
+
+  template <class T>
+  PyObject* object_base_initializer(T const& x)
+  {
+      typedef typename is_derived<
+          typename objects::unforward_cref<T>::type
+        , object
+      >::type is_obj;
+
+      return object_initializer<
+          typename unwrap_reference<T>::type
+      >::get(
+            x
+          , is_obj()
+      );
+  }
+
+  class object : public object_base
+  {
+   public:
+
+      object();
+
+
+      template <class T>
+      explicit object(
+          T const& x
+
+
+
+
+
+      )
+        : object_base(object_base_initializer(x))
+      {
+      }
+
+
+      explicit object(handle<> const&);
+   private:
+
+   public:
+      explicit object(detail::borrowed_reference);
+      explicit object(detail::new_reference);
+      explicit object(detail::new_non_null_reference);
+  };
+# 376 "/usr/include/boost-1_42/boost/python/object_core.hpp"
+  template <bool is_proxy = false, bool is_object_manager = false>
+  struct object_initializer_impl
+  {
+      static PyObject*
+      get(object const& x, mpl::true_)
+      {
+          return python::incref(x.ptr());
+      }
+
+      template <class T>
+      static PyObject*
+      get(T const& x, mpl::false_)
+      {
+          return python::incref(converter::arg_to_python<T>(x).get());
+      }
+  };
+
+  template <>
+  struct object_initializer_impl<true, false>
+  {
+      template <class Policies>
+      static PyObject*
+      get(proxy<Policies> const& x, mpl::false_)
+      {
+          return python::incref(x.operator object().ptr());
+      }
+  };
+
+  template <>
+  struct object_initializer_impl<false, true>
+  {
+      template <class T, class U>
+      static PyObject*
+      get(T const& x, U)
+      {
+          return python::incref(get_managed_object(x, boost::python::tag));
+      }
+  };
+
+  template <>
+  struct object_initializer_impl<true, true>
+  {};
+
+  template <class T>
+  struct object_initializer : object_initializer_impl<
+      is_proxy<T>::value
+    , converter::is_object_manager<T>::value
+  >
+  {};
+
+}
+using api::object;
+template <class T> struct extract;
+
+
+
+
+
+namespace detail
+{
+
+class call_proxy
+{
+public:
+  call_proxy(object target) : m_target(target) {}
+  operator object() const { return m_target;}
+
+ private:
+    object m_target;
+};
+
+class kwds_proxy : public call_proxy
+{
+public:
+  kwds_proxy(object o = object()) : call_proxy(o) {}
+};
+class args_proxy : public call_proxy
+{
+public:
+  args_proxy(object o) : call_proxy(o) {}
+  kwds_proxy operator* () const { return kwds_proxy(*this);}
+};
+}
+
+template <typename U>
+detail::args_proxy api::object_operators<U>::operator* () const
+{
+  object_cref2 x = *static_cast<U const*>(this);
+  return boost::python::detail::args_proxy(x);
+}
+
+template <typename U>
+object api::object_operators<U>::operator()(detail::args_proxy const &args) const
+{
+  U const& self = *static_cast<U const*>(this);
+  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag),
+                                   args.operator object().ptr(),
+                                   0);
+  return object(boost::python::detail::new_reference(result));
+
+}
+
+template <typename U>
+object api::object_operators<U>::operator()(detail::args_proxy const &args,
+                                            detail::kwds_proxy const &kwds) const
+{
+  U const& self = *static_cast<U const*>(this);
+  PyObject *result = PyObject_Call(get_managed_object(self, boost::python::tag),
+                                   args.operator object().ptr(),
+                                   kwds.operator object().ptr());
+  return object(boost::python::detail::new_reference(result));
+
+}
+
+
+template <typename U>
+template <class T>
+object api::object_operators<U>::contains(T const& key) const
+{
+    return this->attr("__contains__")(object(key));
+}
+
+
+inline object::object()
+    : object_base(python::incref((&_Py_NoneStruct)))
+{}
+
+
+inline api::object_base::object_base(object_base const& rhs)
+    : m_ptr(python::incref(rhs.m_ptr))
+{}
+
+inline api::object_base::object_base(PyObject* p)
+    : m_ptr(p)
+{}
+
+inline api::object_base& api::object_base::operator=(api::object_base const& rhs)
+{
+    ( ((PyObject*)(rhs.m_ptr))->ob_refcnt++);
+    if ( --((PyObject*)(this->m_ptr))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(this->m_ptr)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(this->m_ptr))));
+    this->m_ptr = rhs.m_ptr;
+    return *this;
+}
+
+inline api::object_base::~object_base()
+{
+    if ( --((PyObject*)(m_ptr))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(m_ptr)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(m_ptr))));
+}
+
+inline object::object(detail::borrowed_reference p)
+    : object_base(python::incref((PyObject*)p))
+{}
+
+inline object::object(detail::new_reference p)
+    : object_base(expect_non_null((PyObject*)p))
+{}
+
+inline object::object(detail::new_non_null_reference p)
+    : object_base((PyObject*)p)
+{}
+
+inline PyObject* api::object_base::ptr() const
+{
+    return m_ptr;
+}
+
+
+
+
+namespace converter
+{
+  template <class T> struct object_manager_traits;
+
+  template <>
+  struct object_manager_traits<object>
+  {
+      static const bool is_specialized = true;
+      static bool check(PyObject*) { return true; }
+
+      static python::detail::new_non_null_reference adopt(PyObject* x)
+      {
+          return python::detail::new_non_null_reference(x);
+      }
+
+      static PyTypeObject const *get_pytype() {return 0;}
+
+  };
+}
+
+inline PyObject* get_managed_object(object const& x, tag_t)
+{
+    return x.ptr();
+}
+
+}}
+
+# 1 "/usr/include/boost-1_42/boost/python/slice_nil.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/slice_nil.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object_core.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/slice_nil.hpp" 2
+
+namespace boost { namespace python { namespace api {
+
+class slice_nil : public object
+{
+ public:
+    slice_nil() : object() {}
+};
+
+
+static const slice_nil _ = slice_nil();
+
+
+template <class T>
+struct slice_bound
+{
+    typedef object type;
+};
+
+template <>
+struct slice_bound<slice_nil>
+{
+    typedef slice_nil type;
+};
+
+}
+
+using api::slice_nil;
+
+using api::_;
+
+
+}}
+# 573 "/usr/include/boost-1_42/boost/python/object_core.hpp" 2
+# 26 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 30 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+
+namespace boost { namespace python {
+
+typedef detail::keywords<1> arg;
+typedef arg arg_;
+
+namespace detail
+{
+  template <std::size_t nkeywords>
+  struct keywords_base
+  {
+      static const std::size_t size = nkeywords;
+
+      keyword_range range() const
+      {
+          return keyword_range(elements, elements + nkeywords);
+      }
+
+      keyword elements[nkeywords];
+
+      keywords<nkeywords+1>
+      operator,(python::arg const &k) const;
+
+      keywords<nkeywords + 1>
+      operator,(char const *name) const;
+  };
+
+  template <std::size_t nkeywords>
+  struct keywords : keywords_base<nkeywords>
+  {
+  };
+
+  template <>
+  struct keywords<1> : keywords_base<1>
+  {
+      explicit keywords(char const *name)
+      {
+          elements[0].name = name;
+      }
+
+      template <class T>
+      python::arg& operator=(T const& value)
+      {
+          object z(value);
+          elements[0].default_value = handle<>(python::borrowed(object(value).ptr()));
+          return *this;
+      }
+
+      operator detail::keyword const&() const
+      {
+          return elements[0];
+      }
+  };
+
+  template <std::size_t nkeywords>
+  inline
+  keywords<nkeywords+1>
+  keywords_base<nkeywords>::operator,(python::arg const &k) const
+  {
+      keywords<nkeywords> const& l = *static_cast<keywords<nkeywords> const*>(this);
+      python::detail::keywords<nkeywords+1> res;
+      std::copy(l.elements, l.elements+nkeywords, res.elements);
+      res.elements[nkeywords] = k.elements[0];
+      return res;
+  }
+
+  template <std::size_t nkeywords>
+  inline
+  keywords<nkeywords + 1>
+  keywords_base<nkeywords>::operator,(char const *name) const
+  {
+      return this->operator,(python::arg(name));
+  }
+
+
+  template<typename T>
+  struct is_keywords
+  {
+      static const bool value = false;
+  };
+
+  template<std::size_t nkeywords>
+  struct is_keywords<keywords<nkeywords> >
+  {
+      static const bool value = true;
+  };
+  template <class T>
+  struct is_reference_to_keywords
+  {
+      static const bool is_ref = is_reference<T>::value;
+      typedef typename remove_reference<T>::type deref;
+      typedef typename remove_cv<deref>::type key_t;
+      static const bool is_key = is_keywords<key_t>::value;
+      static const bool value = (is_ref & is_key);
+
+      typedef mpl::bool_<value> type;
+     
+  };
+# 154 "/usr/include/boost-1_42/boost/python/args.hpp"
+}
+
+inline detail::keywords<1> args(char const* name)
+{
+    return detail::keywords<1>(name);
+}
+# 170 "/usr/include/boost-1_42/boost/python/args.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 40 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        inline detail::keywords<2> args( char const* name0 , char const* name1) { detail::keywords<2> result; result.elements[0].name = name0; result.elements[1].name = name1; return result; }
+
+
+        inline detail::keywords<3> args( char const* name0 , char const* name1 , char const* name2) { detail::keywords<3> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; return result; }
+
+
+        inline detail::keywords<4> args( char const* name0 , char const* name1 , char const* name2 , char const* name3) { detail::keywords<4> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; return result; }
+
+
+        inline detail::keywords<5> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4) { detail::keywords<5> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; return result; }
+
+
+        inline detail::keywords<6> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5) { detail::keywords<6> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; return result; }
+
+
+        inline detail::keywords<7> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6) { detail::keywords<7> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; return result; }
+
+
+        inline detail::keywords<8> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7) { detail::keywords<8> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; return result; }
+
+
+        inline detail::keywords<9> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8) { detail::keywords<9> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; return result; }
+
+
+        inline detail::keywords<10> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9) { detail::keywords<10> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; return result; }
+
+
+        inline detail::keywords<11> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10) { detail::keywords<11> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; return result; }
+
+
+        inline detail::keywords<12> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11) { detail::keywords<12> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; return result; }
+
+
+        inline detail::keywords<13> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11 , char const* name12) { detail::keywords<13> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; result.elements[12].name = name12; return result; }
+
+
+        inline detail::keywords<14> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11 , char const* name12 , char const* name13) { detail::keywords<14> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; result.elements[12].name = name12; result.elements[13].name = name13; return result; }
+
+
+        inline detail::keywords<15> args( char const* name0 , char const* name1 , char const* name2 , char const* name3 , char const* name4 , char const* name5 , char const* name6 , char const* name7 , char const* name8 , char const* name9 , char const* name10 , char const* name11 , char const* name12 , char const* name13 , char const* name14) { detail::keywords<15> result; result.elements[0].name = name0; result.elements[1].name = name1; result.elements[2].name = name2; result.elements[3].name = name3; result.elements[4].name = name4; result.elements[5].name = name5; result.elements[6].name = name6; result.elements[7].name = name7; result.elements[8].name = name8; result.elements[9].name = name9; result.elements[10].name = name10; result.elements[11].name = name11; result.elements[12].name = name12; result.elements[13].name = name13; result.elements[14].name = name14; return result; }
+# 171 "/usr/include/boost-1_42/boost/python/args.hpp" 2
+
+}}
+# 12 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/bases.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/bases.hpp"
+namespace boost { namespace python {
+
+
+
+
+  template < typename Base0 = mpl::void_ >
+  struct bases : detail::type_list< Base0 >::type
+  {};
+
+  namespace detail
+  {
+
+    template <class T> struct specifies_bases
+        : mpl::false_
+    {
+    };
+
+    template < class Base0 >
+    struct specifies_bases< bases< Base0 > >
+        : mpl::true_
+    {
+    };
+# 55 "/usr/include/boost-1_42/boost/python/bases.hpp"
+    template <class T, class Prev = bases<> >
+    struct select_bases
+        : mpl::if_<
+                specifies_bases<T>
+                , T
+                , Prev
+          >
+    {
+    };
+  }
+
+}}
+# 15 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+namespace boost { namespace python {
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+   
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+   
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" ")")
+           
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" ")")
+            , converter::arg_to_python<A0>(a0).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/call_method.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+
+
+
+
+template <
+    class R
+    , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14
+    >
+typename detail::returnable<R>::type
+call_method(PyObject* self, char const* name
+    , A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14
+    , boost::type<R>* = 0
+    )
+{
+    PyObject* const result =
+        PyEval_CallMethod(
+            self
+            , const_cast<char*>(name)
+            , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get() , converter::arg_to_python<A14>(a14).get()
+            );
+# 75 "/usr/include/boost-1_42/boost/python/call_method.hpp"
+    converter::return_from_python<R> converter;
+    return converter(result);
+}
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/python/call_method.hpp" 2
+
+
+
+}}
+# 18 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/class.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/class.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/class_fwd.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/class_fwd.hpp"
+namespace boost { namespace python {
+
+template <
+    class T
+
+    , class X1 = ::boost::python::detail::not_specified
+    , class X2 = ::boost::python::detail::not_specified
+    , class X3 = ::boost::python::detail::not_specified
+    >
+class class_;
+
+}}
+# 13 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/class.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/object/class.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 13 "/usr/include/boost-1_42/boost/python/object/class.hpp" 2
+
+namespace boost { namespace python {
+
+namespace objects {
+
+struct class_base : python::api::object
+{
+
+    class_base(
+        char const* name
+
+        , std::size_t num_types
+        , type_info const*const types
+
+
+        , char const* doc = 0
+        );
+
+
+
+
+    void enable_pickling_(bool getstate_manages_dict);
+
+ protected:
+    void add_property(
+        char const* name, object const& fget, char const* docstr);
+    void add_property(char const* name,
+        object const& fget, object const& fset, char const* docstr);
+
+    void add_static_property(char const* name, object const& fget);
+    void add_static_property(char const* name, object const& fget, object const& fset);
+
+
+    void setattr(char const* name, object const&);
+
+
+
+
+    void set_instance_size(std::size_t bytes);
+
+
+
+    void def_no_init();
+
+
+
+    void make_method_static(const char *method_name);
+};
+
+}}}
+# 14 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/object.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object_attributes.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object_attributes.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/proxy.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/proxy.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/object_operators.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/call.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp" 2
+
+
+
+
+
+
+
+namespace boost
+{
+
+  namespace iterators
+  {
+
+
+
+    template<bool>
+    struct enabled
+    {
+      template<typename T>
+      struct base
+      {
+        typedef T type;
+      };
+    };
+
+
+
+
+
+
+    template<>
+    struct enabled<false>
+    {
+      template<typename T>
+      struct base
+      {
+# 62 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp"
+      };
+    };
+
+
+    template <class Cond,
+              class Return>
+    struct enable_if
+
+      : enabled<(Cond::value)>::template base<Return>
+
+
+
+    {
+
+
+
+    };
+
+  }
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
+# 85 "/usr/include/boost-1_42/boost/iterator/detail/enable_if.hpp" 2
+# 13 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2
+
+namespace boost { namespace python { namespace api {
+
+template <class X>
+char is_object_operators_helper(object_operators<X> const*);
+
+typedef char (&no_type)[2];
+no_type is_object_operators_helper(...);
+
+template <class X> X* make_ptr();
+
+template <class L, class R = L>
+struct is_object_operators
+{
+    enum {
+        value
+        = (sizeof(api::is_object_operators_helper(api::make_ptr<L>()))
+           + sizeof(api::is_object_operators_helper(api::make_ptr<R>()))
+           < 4
+        )
+    };
+    typedef mpl::bool_<value> type;
+};
+
+
+template <class L, class R, class T>
+struct enable_binary
+  : boost::iterators::enable_if<is_object_operators<L,R>, T>
+{};
+
+
+
+
+
+template <class U>
+object object_operators<U>::operator()() const
+{
+    object_cref2 f = *static_cast<U const*>(this);
+    return call<object>(f.ptr());
+}
+
+
+template <class U>
+inline
+object_operators<U>::operator bool_type() const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    int is_true = PyObject_IsTrue(x.ptr());
+    if (is_true < 0) throw_error_already_set();
+    return is_true ? &object::ptr : 0;
+}
+
+template <class U>
+inline bool
+object_operators<U>::operator!() const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    int is_true = PyObject_IsTrue(x.ptr());
+    if (is_true < 0) throw_error_already_set();
+    return !is_true;
+}
+# 94 "/usr/include/boost-1_42/boost/python/object_operators.hpp"
+ object operator >(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator >(L const& l, R const& r) { return object(l) > object(r); }
+ object operator >=(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator >=(L const& l, R const& r) { return object(l) >= object(r); }
+ object operator <(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator <(L const& l, R const& r) { return object(l) < object(r); }
+ object operator <=(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator <=(L const& l, R const& r) { return object(l) <= object(r); }
+ object operator ==(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator ==(L const& l, R const& r) { return object(l) == object(r); }
+ object operator !=(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator !=(L const& l, R const& r) { return object(l) != object(r); }
+ object operator +(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator +(L const& l, R const& r) { return object(l) + object(r); }
+ object operator -(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator -(L const& l, R const& r) { return object(l) - object(r); }
+ object operator *(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator *(L const& l, R const& r) { return object(l) * object(r); }
+ object operator /(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator /(L const& l, R const& r) { return object(l) / object(r); }
+ object operator %(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator %(L const& l, R const& r) { return object(l) % object(r); }
+ object operator <<(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator <<(L const& l, R const& r) { return object(l) << object(r); }
+ object operator >>(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator >>(L const& l, R const& r) { return object(l) >> object(r); }
+ object operator &(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator &(L const& l, R const& r) { return object(l) & object(r); }
+ object operator ^(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator ^(L const& l, R const& r) { return object(l) ^ object(r); }
+ object operator |(object const& l, object const& r); template <class L, class R> typename enable_binary<L,R,object>::type operator |(L const& l, R const& r) { return object(l) | object(r); }
+# 120 "/usr/include/boost-1_42/boost/python/object_operators.hpp"
+ object& operator +=(object& l, object const& r); template <class R> object& operator +=(object& l, R const& r) { return l += object(r); }
+ object& operator -=(object& l, object const& r); template <class R> object& operator -=(object& l, R const& r) { return l -= object(r); }
+ object& operator *=(object& l, object const& r); template <class R> object& operator *=(object& l, R const& r) { return l *= object(r); }
+ object& operator /=(object& l, object const& r); template <class R> object& operator /=(object& l, R const& r) { return l /= object(r); }
+ object& operator %=(object& l, object const& r); template <class R> object& operator %=(object& l, R const& r) { return l %= object(r); }
+ object& operator <<=(object& l, object const& r); template <class R> object& operator <<=(object& l, R const& r) { return l <<= object(r); }
+ object& operator >>=(object& l, object const& r); template <class R> object& operator >>=(object& l, R const& r) { return l >>= object(r); }
+ object& operator &=(object& l, object const& r); template <class R> object& operator &=(object& l, R const& r) { return l &= object(r); }
+ object& operator ^=(object& l, object const& r); template <class R> object& operator ^=(object& l, R const& r) { return l ^= object(r); }
+ object& operator |=(object& l, object const& r); template <class R> object& operator |=(object& l, R const& r) { return l |= object(r); }
+
+
+}}}
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
+# 135 "/usr/include/boost-1_42/boost/python/object_operators.hpp" 2
+# 10 "/usr/include/boost-1_42/boost/python/proxy.hpp" 2
+
+namespace boost { namespace python { namespace api {
+
+template <class Policies>
+class proxy : public object_operators<proxy<Policies> >
+{
+    typedef typename Policies::key_type key_type;
+
+
+    typedef proxy const& assignment_self;
+
+
+
+ public:
+    proxy(object const& target, key_type const& key);
+    operator object() const;
+
+
+    proxy const& operator=(assignment_self) const;
+
+    template <class T>
+    inline proxy const& operator=(T const& rhs) const
+    {
+        Policies::set(m_target, m_key, object(rhs));
+        return *this;
+    }
+
+ public:
+    void del() const;
+
+ private:
+    object m_target;
+    key_type m_key;
+};
+
+
+template <class T>
+inline void del(proxy<T> const& x)
+{
+    x.del();
+}
+
+
+
+
+
+template <class Policies>
+inline proxy<Policies>::proxy(object const& target, key_type const& key)
+    : m_target(target), m_key(key)
+{}
+
+template <class Policies>
+inline proxy<Policies>::operator object() const
+{
+    return Policies::get(m_target, m_key);
+}
+
+
+template <class Policies>
+inline proxy<Policies> const& proxy<Policies>::operator=(typename proxy::assignment_self rhs) const
+{
+    return *this = python::object(rhs);
+}
+# 81 "/usr/include/boost-1_42/boost/python/proxy.hpp"
+template <class Policies, class R> proxy<Policies> const& operator +=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old += rhs); }
+template <class Policies, class R> proxy<Policies> const& operator -=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old -= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator *=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old *= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator /=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old /= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator %=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old %= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator <<=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old <<= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator >>=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old >>= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator &=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old &= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator ^=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old ^= rhs); }
+template <class Policies, class R> proxy<Policies> const& operator |=(proxy<Policies> const& lhs, R const& rhs) { object old(lhs); return lhs = (old |= rhs); }
+
+
+template <class Policies>
+inline void proxy<Policies>::del() const
+{
+    Policies::del(m_target, m_key);
+}
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/object_attributes.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/object_protocol.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object_protocol.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object_protocol_core.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/object_protocol_core.hpp"
+namespace boost { namespace python {
+
+namespace api
+{
+  class object;
+
+  object getattr(object const& target, object const& key);
+  object getattr(object const& target, object const& key, object const& default_);
+  void setattr(object const& target, object const& key, object const& value);
+  void delattr(object const& target, object const& key);
+
+
+
+  object getattr(object const& target, char const* key);
+  object getattr(object const& target, char const* key, object const& default_);
+  void setattr(object const& target, char const* key, object const& value);
+  void delattr(object const& target, char const* key);
+
+  object getitem(object const& target, object const& key);
+  void setitem(object const& target, object const& key, object const& value);
+  void delitem(object const& target, object const& key);
+
+  object getslice(object const& target, handle<> const& begin, handle<> const& end);
+  void setslice(object const& target, handle<> const& begin, handle<> const& end, object const& value);
+  void delslice(object const& target, handle<> const& begin, handle<> const& end);
+}
+
+using api::getattr;
+using api::setattr;
+using api::delattr;
+
+using api::getitem;
+using api::setitem;
+using api::delitem;
+
+using api::getslice;
+using api::setslice;
+using api::delslice;
+
+}}
+# 11 "/usr/include/boost-1_42/boost/python/object_protocol.hpp" 2
+
+
+
+
+namespace boost { namespace python { namespace api {
+# 26 "/usr/include/boost-1_42/boost/python/object_protocol.hpp"
+template <class Target, class Key>
+object getattr(Target const& target, Key const& key )
+{
+    return getattr(object(target), object(key));
+}
+
+template <class Target, class Key, class Default>
+object getattr(Target const& target, Key const& key, Default const& default_ )
+{
+    return getattr(object(target), object(key), object(default_));
+}
+
+
+template <class Key, class Value>
+void setattr(object const& target, Key const& key, Value const& value )
+{
+    setattr(target, object(key), object(value));
+}
+
+template <class Key>
+void delattr(object const& target, Key const& key )
+{
+    delattr(target, object(key));
+}
+
+template <class Target, class Key>
+object getitem(Target const& target, Key const& key )
+{
+    return getitem(object(target), object(key));
+}
+
+
+template <class Key, class Value>
+void setitem(object const& target, Key const& key, Value const& value )
+{
+    setitem(target, object(key), object(value));
+}
+
+template <class Key>
+void delitem(object const& target, Key const& key )
+{
+    delitem(target, object(key));
+}
+
+template <class Target, class Begin, class End>
+object getslice(Target const& target, Begin const& begin, End const& end)
+{
+    return getslice(object(target), object(begin), object(end));
+}
+
+template <class Begin, class End, class Value>
+void setslice(object const& target, Begin const& begin, End const& end, Value const& value)
+{
+    setslice(target, object(begin), object(end), object(value));
+}
+
+template <class Begin, class End>
+void delslice(object const& target, Begin const& begin, End const& end)
+{
+    delslice(target, object(begin), object(end));
+}
+
+}}}
+# 13 "/usr/include/boost-1_42/boost/python/object_attributes.hpp" 2
+
+namespace boost { namespace python { namespace api {
+
+struct const_attribute_policies
+{
+    typedef char const* key_type;
+    static object get(object const& target, char const* key);
+    static object get(object const& target, object const& key);
+};
+
+struct attribute_policies : const_attribute_policies
+{
+    static object const& set(object const& target, char const* key, object const& value);
+    static void del(object const&target, char const* key);
+};
+
+struct const_objattribute_policies
+{
+    typedef object const key_type;
+    static object get(object const& target, object const& key);
+};
+
+struct objattribute_policies : const_objattribute_policies
+{
+    static object const& set(object const& target, object const& key, object const& value);
+    static void del(object const&target, object const& key);
+};
+
+
+
+
+template <class U>
+inline object_attribute object_operators<U>::attr(char const* name)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_attribute(x, name);
+}
+
+template <class U>
+inline const_object_attribute object_operators<U>::attr(char const* name) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_attribute(x, name);
+}
+
+template <class U>
+inline object_objattribute object_operators<U>::attr(object const& name)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_objattribute(x, name);
+}
+
+template <class U>
+inline const_object_objattribute object_operators<U>::attr(object const& name) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_objattribute(x, name);
+}
+
+inline object const_attribute_policies::get(object const& target, char const* key)
+{
+    return python::getattr(target, key);
+}
+
+inline object const_objattribute_policies::get(object const& target, object const& key)
+{
+    return python::getattr(target, key);
+}
+
+inline object const& attribute_policies::set(
+    object const& target
+    , char const* key
+    , object const& value)
+{
+    python::setattr(target, key, value);
+    return value;
+}
+
+inline object const& objattribute_policies::set(
+    object const& target
+    , object const& key
+    , object const& value)
+{
+    python::setattr(target, key, value);
+    return value;
+}
+
+inline void attribute_policies::del(
+    object const& target
+    , char const* key)
+{
+    python::delattr(target, key);
+}
+
+inline void objattribute_policies::del(
+    object const& target
+    , object const& key)
+{
+    python::delattr(target, key);
+}
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/object.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object_items.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/object_items.hpp"
+namespace boost { namespace python { namespace api {
+
+struct const_item_policies
+{
+    typedef object key_type;
+    static object get(object const& target, object const& key);
+};
+
+struct item_policies : const_item_policies
+{
+    static object const& set(object const& target, object const& key, object const& value);
+    static void del(object const& target, object const& key);
+};
+
+
+
+
+template <class U>
+inline object_item
+object_operators<U>::operator[](object_cref key)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_item(x, key);
+}
+
+template <class U>
+inline const_object_item
+object_operators<U>::operator[](object_cref key) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_item(x, key);
+}
+
+
+template <class U>
+template <class T>
+inline const_object_item
+object_operators<U>::operator[](T const& key) const
+{
+    return (*this)[object(key)];
+}
+
+template <class U>
+template <class T>
+inline object_item
+object_operators<U>::operator[](T const& key)
+{
+    return (*this)[object(key)];
+}
+
+
+
+inline object const_item_policies::get(object const& target, object const& key)
+{
+    return getitem(target, key);
+}
+
+inline object const& item_policies::set(
+    object const& target
+    , object const& key
+    , object const& value)
+{
+    setitem(target, key, value);
+    return value;
+}
+
+inline void item_policies::del(
+    object const& target
+    , object const& key)
+{
+    delitem(target, key);
+}
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/object.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object_slices.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/object_slices.hpp"
+namespace boost { namespace python { namespace api {
+
+struct const_slice_policies
+{
+    typedef std::pair<handle<>, handle<> > key_type;
+    static object get(object const& target, key_type const& key);
+};
+
+struct slice_policies : const_slice_policies
+{
+    static object const& set(object const& target, key_type const& key, object const& value);
+    static void del(object const& target, key_type const& key);
+};
+
+template <class T, class U>
+inline slice_policies::key_type slice_key(T x, U y)
+{
+    return slice_policies::key_type(handle<>(x), handle<>(y));
+}
+
+
+
+
+template <class U>
+object_slice
+object_operators<U>::slice(object_cref start, object_cref finish)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
+}
+
+template <class U>
+const_object_slice
+object_operators<U>::slice(object_cref start, object_cref finish) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_slice(x, api::slice_key(borrowed(start.ptr()), borrowed(finish.ptr())));
+}
+
+template <class U>
+object_slice
+object_operators<U>::slice(slice_nil, object_cref finish)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
+}
+
+template <class U>
+const_object_slice
+object_operators<U>::slice(slice_nil, object_cref finish) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), borrowed(finish.ptr())));
+}
+
+template <class U>
+object_slice
+object_operators<U>::slice(slice_nil, slice_nil)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
+}
+
+template <class U>
+const_object_slice
+object_operators<U>::slice(slice_nil, slice_nil) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_slice(x, api::slice_key(allow_null((PyObject*)0), allow_null((PyObject*)0)));
+}
+
+template <class U>
+object_slice
+object_operators<U>::slice(object_cref start, slice_nil)
+{
+    object_cref2 x = *static_cast<U*>(this);
+    return object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
+}
+
+template <class U>
+const_object_slice
+object_operators<U>::slice(object_cref start, slice_nil) const
+{
+    object_cref2 x = *static_cast<U const*>(this);
+    return const_object_slice(x, api::slice_key(borrowed(start.ptr()), allow_null((PyObject*)0)));
+}
+
+template <class U>
+template <class T, class V>
+inline const_object_slice
+object_operators<U>::slice(T const& start, V const& end) const
+{
+    return this->slice(
+        typename slice_bound<T>::type(start)
+        , typename slice_bound<V>::type(end));
+}
+
+template <class U>
+template <class T, class V>
+inline object_slice
+object_operators<U>::slice(T const& start, V const& end)
+{
+    return this->slice(
+        typename slice_bound<T>::type(start)
+        , typename slice_bound<V>::type(end));
+}
+
+
+
+inline object const_slice_policies::get(object const& target, key_type const& key)
+{
+    return getslice(target, key.first, key.second);
+}
+
+inline object const& slice_policies::set(
+    object const& target
+    , key_type const& key
+    , object const& value)
+{
+    setslice(target, key.first, key.second, value);
+    return value;
+}
+
+inline void slice_policies::del(
+    object const& target
+    , key_type const& key)
+{
+    delslice(target, key.first, key.second);
+}
+
+}}}
+# 13 "/usr/include/boost-1_42/boost/python/object.hpp" 2
+
+
+
+namespace boost { namespace python {
+
+    inline ssize_t len(object const& obj)
+    {
+        ssize_t result = PyObject_Size(obj.ptr());
+        if (PyErr_Occurred()) throw_error_already_set();
+        return result;
+    }
+
+}}
+# 16 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/data_members.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/return_value_policy.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/return_value_policy.hpp"
+namespace boost { namespace python {
+
+template <class ResultConverterGenerator, class BasePolicy_ = default_call_policies>
+struct return_value_policy : BasePolicy_
+{
+    typedef ResultConverterGenerator result_converter;
+};
+
+}}
+# 13 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/return_by_value.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/return_by_value.hpp"
+namespace boost { namespace python {
+
+struct return_by_value
+{
+    template <class R>
+    struct apply
+    {
+       typedef to_python_value<
+           typename detail::value_arg<R>::type
+       > type;
+    };
+};
+
+}}
+# 14 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/reference_existing_object.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/reference_existing_object.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class R>
+  struct reference_existing_object_requires_a_pointer_or_reference_return_type
+
+  {}
+
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct reference_existing_object
+{
+    template <class T>
+    struct apply
+    {
+        static const bool ok = is_pointer<T>::value || is_reference<T>::value
+                                                                      ;
+
+        typedef typename mpl::if_c<
+            ok
+            , to_python_indirect<T, detail::make_reference_holder>
+            , detail::reference_existing_object_requires_a_pointer_or_reference_return_type<T>
+        >::type type;
+    };
+};
+
+}}
+# 12 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/with_custodian_and_ward.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/with_custodian_and_ward.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/life_support.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/object/life_support.hpp"
+namespace boost { namespace python { namespace objects {
+
+ PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient);
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/with_custodian_and_ward.hpp" 2
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <std::size_t N>
+  struct get_prev
+  {
+      template <class ArgumentPackage>
+      static PyObject* execute(ArgumentPackage const& args, PyObject* = 0)
+      {
+          int const pre_n = static_cast<int>(N) - 1;
+          return detail::get(mpl::int_<pre_n>(), args);
+      }
+  };
+  template <>
+  struct get_prev<0>
+  {
+      template <class ArgumentPackage>
+      static PyObject* execute(ArgumentPackage const&, PyObject* zeroth)
+      {
+          return zeroth;
+      }
+  };
+}
+template <
+    std::size_t custodian
+  , std::size_t ward
+  , class BasePolicy_ = default_call_policies
+>
+struct with_custodian_and_ward : BasePolicy_
+{
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((custodian != ward) == 0 ? false : true) >)> boost_static_assert_typedef_45;
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((custodian > 0) == 0 ? false : true) >)> boost_static_assert_typedef_46;
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((ward > 0) == 0 ? false : true) >)> boost_static_assert_typedef_47;
+
+    template <class ArgumentPackage>
+    static bool precall(ArgumentPackage const& args_)
+    {
+        unsigned arity_ = detail::arity(args_);
+        if (custodian > arity_ || ward > arity_)
+        {
+            PyErr_SetString(
+                PyExc_IndexError
+              , "boost::python::with_custodian_and_ward: argument index out of range"
+            );
+            return false;
+        }
+
+        PyObject* patient = detail::get_prev<ward>::execute(args_);
+        PyObject* nurse = detail::get_prev<custodian>::execute(args_);
+
+        PyObject* life_support = python::objects::make_nurse_and_patient(nurse, patient);
+        if (life_support == 0)
+            return false;
+
+        bool result = BasePolicy_::precall(args_);
+
+        if (!result) {
+            if ( --((PyObject*)(life_support))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(life_support)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(life_support))));
+        }
+
+        return result;
+    }
+};
+
+template <std::size_t custodian, std::size_t ward, class BasePolicy_ = default_call_policies>
+struct with_custodian_and_ward_postcall : BasePolicy_
+{
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((custodian != ward) == 0 ? false : true) >)> boost_static_assert_typedef_82;
+
+    template <class ArgumentPackage>
+    static PyObject* postcall(ArgumentPackage const& args_, PyObject* result)
+    {
+        std::size_t arity_ = detail::arity(args_);
+
+
+
+
+
+
+        if ( (std::max)(custodian, ward) > arity_ )
+
+        {
+            PyErr_SetString(
+                PyExc_IndexError
+              , "boost::python::with_custodian_and_ward_postcall: argument index out of range"
+            );
+            return 0;
+        }
+
+        PyObject* patient = detail::get_prev<ward>::execute(args_, result);
+        PyObject* nurse = detail::get_prev<custodian>::execute(args_, result);
+
+        if (nurse == 0) return 0;
+
+        result = BasePolicy_::postcall(args_, result);
+        if (result == 0)
+            return 0;
+
+        if (python::objects::make_nurse_and_patient(nurse, patient) == 0)
+        {
+            if ((result) == __null) ; else if ( --((PyObject*)(result))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(result)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(result))));
+            return 0;
+        }
+        return result;
+    }
+};
+
+
+}}
+# 13 "/usr/include/boost-1_42/boost/python/return_internal_reference.hpp" 2
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <std::size_t>
+  struct return_internal_reference_owner_arg_must_be_greater_than_zero
+
+  {}
+
+  ;
+}
+
+template <std::size_t owner_arg = 1, class BasePolicy_ = default_call_policies>
+struct return_internal_reference
+    : with_custodian_and_ward_postcall<0, owner_arg, BasePolicy_>
+{
+ private:
+    static const bool legal = owner_arg > 0;
+ public:
+    typedef typename mpl::if_c<
+        legal
+        , reference_existing_object
+        , detail::return_internal_reference_owner_arg_must_be_greater_than_zero<owner_arg>
+    >::type result_converter;
+};
+
+}}
+# 15 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/make_function.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/make_function.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/make_function.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/object/function_object.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/function/function2.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/function/function2.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/function_template.hpp" 1
+# 81 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+namespace boost {
+  namespace detail {
+    namespace function {
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+        >
+      struct function_invoker2
+      {
+        static R invoke(function_buffer& function_ptr ,
+                        T0 a0 , T1 a1)
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          return f( a0 , a1);
+        }
+      };
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+        >
+      struct void_function_invoker2
+      {
+        static void
+        invoke(function_buffer& function_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
+          f( a0 , a1);
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_obj_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1);
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct void_function_obj_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f;
+          if (function_allows_small_object_optimization<FunctionObj>::value)
+            f = reinterpret_cast<FunctionObj*>(&function_obj_ptr.data);
+          else
+            f = reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1);
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_ref_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          return (*f)( a0 , a1);
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct void_function_ref_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          FunctionObj* f =
+            reinterpret_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          (*f)( a0 , a1);
+        }
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_mem_invoker2
+      {
+        static R invoke(function_buffer& function_obj_ptr ,
+                        T0 a0 , T1 a1)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)( a0 , a1);
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct function_void_mem_invoker2
+      {
+        static void
+        invoke(function_buffer& function_obj_ptr ,
+               T0 a0 , T1 a1)
+
+        {
+          MemberPtr* f =
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          boost::mem_fn(*f)( a0 , a1);
+        }
+      };
+
+
+      template<
+        typename FunctionPtr,
+        typename R ,
+        typename T0 , typename T1
+      >
+      struct get_function_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_invoker2<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_invoker2<
+                            FunctionPtr,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_function_obj_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_obj_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_obj_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+
+      template<
+        typename FunctionObj,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_function_ref_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            void_function_ref_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_ref_invoker2<
+                            FunctionObj,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+
+
+
+      template<
+        typename MemberPtr,
+        typename R ,
+        typename T0 , typename T1
+       >
+      struct get_member_invoker2
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            function_void_mem_invoker2<
+                            MemberPtr,
+                            R ,
+                            T0 , T1
+                          >,
+                          function_mem_invoker2<
+                            MemberPtr,
+                            R ,
+                            T0 , T1
+                          >
+                       >::type type;
+      };
+# 326 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+      template<typename Tag>
+      struct get_invoker2 { };
+
+
+      template<>
+      struct get_invoker2<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_invoker2<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_invoker2<
+                             FunctionPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker2<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_member_invoker2<
+                             MemberPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_member_invoker2<
+                             MemberPtr,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+
+
+
+      template<>
+      struct get_invoker2<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_obj_invoker2<
+                             FunctionObj,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_obj_invoker2<
+                             FunctionObj,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+
+      template<>
+      struct get_invoker2<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1>
+        struct apply
+        {
+          typedef typename get_function_ref_invoker2<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper,
+                 typename R , typename T0 , typename T1,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename get_function_ref_invoker2<
+                             typename RefWrapper::type,
+                             R ,
+                             T0 , T1
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+# 475 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+      template<typename R , typename T0 , typename T1>
+      struct basic_vtable2
+      {
+
+        typedef R result_type;
+
+
+
+
+        typedef result_type (*invoker_type)(function_buffer&
+                                            ,
+                                            T0 , T1);
+
+        template<typename F>
+        bool assign_to(F f, function_buffer& functor)
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to(f, functor, tag());
+        }
+        template<typename F,typename Allocator>
+        bool assign_to_a(F f, function_buffer& functor, Allocator a)
+        {
+          typedef typename get_function_tag<F>::type tag;
+          return assign_to_a(f, functor, a, tag());
+        }
+
+        void clear(function_buffer& functor)
+        {
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
+        }
+
+      private:
+
+        template<typename FunctionPtr>
+        bool
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
+        {
+          this->clear(functor);
+          if (f) {
+
+
+            functor.func_ptr = (void (*)())(f);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionPtr,typename Allocator>
+        bool
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
+        {
+          return assign_to(f,functor,function_ptr_tag());
+        }
+
+
+
+        template<typename MemberPtr>
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
+        {
+
+
+
+          if (f) {
+            this->assign_to(mem_fn(f), functor);
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename MemberPtr,typename Allocator>
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
+        {
+
+
+
+          if (f) {
+            this->assign_to_a(mem_fn(f), functor, a);
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
+        {
+          new ((void*)&functor.data) FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
+        {
+          assign_functor(f,functor,mpl::true_());
+        }
+
+
+        template<typename FunctionObj>
+        void
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
+        {
+          functor.obj_ptr = new FunctionObj(f);
+        }
+        template<typename FunctionObj,typename Allocator>
+        void
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
+        {
+          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
+          typedef typename Allocator::template rebind<functor_wrapper_type>::other
+            wrapper_allocator_type;
+          typedef typename wrapper_allocator_type::pointer wrapper_allocator_pointer_type;
+          wrapper_allocator_type wrapper_allocator(a);
+          wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
+          wrapper_allocator.construct(copy, functor_wrapper_type(f,a));
+          functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
+          functor.obj_ptr = new_f;
+        }
+
+        template<typename FunctionObj>
+        bool
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor(f, functor,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
+        {
+          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
+            assign_functor_a(f, functor, a,
+                           mpl::bool_<(function_allows_small_object_optimization<FunctionObj>::value)>());
+            return true;
+          } else {
+            return false;
+          }
+        }
+
+
+        template<typename FunctionObj>
+        bool
+        assign_to(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, function_obj_ref_tag)
+        {
+          functor.obj_ref.obj_ptr = (void *)f.get_pointer();
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
+        }
+        template<typename FunctionObj,typename Allocator>
+        bool
+        assign_to_a(const reference_wrapper<FunctionObj>& f,
+                  function_buffer& functor, Allocator, function_obj_ref_tag)
+        {
+          return assign_to(f,functor,function_obj_ref_tag());
+        }
+
+      public:
+        vtable_base base;
+        invoker_type invoker;
+      };
+    }
+  }
+
+  template<
+    typename R ,
+    typename T0 , typename T1
+  >
+  class function2 : public function_base
+
+
+
+
+
+
+
+    , public std::binary_function<T0,T1,R>
+
+
+
+  {
+  public:
+
+    typedef R result_type;
+
+
+
+
+
+  private:
+    typedef boost::detail::function::basic_vtable2<
+              R , T0 , T1>
+      vtable_type;
+
+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~(std::size_t)0x01);
+    }
+
+    struct clear_type {};
+
+  public:
+    static const int args = 2;
+
+
+    template<typename Args>
+    struct sig
+    {
+      typedef result_type type;
+    };
+
+
+
+
+    typedef T0 first_argument_type;
+    typedef T1 second_argument_type;
+
+
+    static const int arity = 2;
+    typedef T0 arg1_type; typedef T1 arg2_type;
+
+    typedef function2 self_type;
+
+    function2() : function_base() { }
+
+
+
+    template<typename Functor>
+    function2(Functor f
+
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to(f);
+    }
+    template<typename Functor,typename Allocator>
+    function2(Functor f, Allocator a
+
+                            ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                             (is_integral<Functor>::value)>::value),
+                                        int>::type = 0
+
+                            ) :
+      function_base()
+    {
+      this->assign_to_a(f,a);
+    }
+
+
+    function2(clear_type*) : function_base() { }
+
+
+
+
+
+
+
+    function2(const function2& f) : function_base()
+    {
+      this->assign_to_own(f);
+    }
+
+    ~function2() { clear(); }
+# 766 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+    result_type operator()( T0 a0 , T1 a1) const;
+
+
+
+
+
+
+
+    template<typename Functor>
+
+    typename enable_if_c<
+               (boost::type_traits::ice_not<
+                 (is_integral<Functor>::value)>::value),
+               function2&>::type
+
+
+
+    operator=(Functor f)
+    {
+      this->clear();
+      { try {
+        this->assign_to(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+    template<typename Functor,typename Allocator>
+    void assign(Functor f, Allocator a)
+    {
+      this->clear();
+      { try{
+        this->assign_to_a(f,a);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+
+
+    function2& operator=(clear_type*)
+    {
+      this->clear();
+      return *this;
+    }
+# 824 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+    function2& operator=(const function2& f)
+    {
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      { try {
+        this->assign_to_own(f);
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+      return *this;
+    }
+
+    void swap(function2& other)
+    {
+      if (&other == this)
+        return;
+
+      function2 tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
+    }
+
+
+    void clear()
+    {
+      if (vtable) {
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
+        vtable = 0;
+      }
+    }
+
+
+
+
+
+  private:
+    struct dummy {
+      void nonnull() {};
+    };
+
+    typedef void (dummy::*safe_bool)();
+
+  public:
+    operator safe_bool () const
+      { return (this->empty())? 0 : &dummy::nonnull; }
+
+    bool operator!() const
+      { return this->empty(); }
+
+
+  private:
+    void assign_to_own(const function2& f)
+    {
+      if (!f.empty()) {
+        this->vtable = f.vtable;
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
+      }
+    }
+
+    template<typename Functor>
+    void assign_to(Functor f)
+    {
+      using detail::function::vtable_base;
+
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker2<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R ,
+                        T0 , T1>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= (std::size_t)0x01;
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+    template<typename Functor,typename Allocator>
+    void assign_to_a(Functor f,Allocator a)
+    {
+      using detail::function::vtable_base;
+
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::get_invoker2<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R ,
+                         T0 , T1,
+                         Allocator>
+        handler_type;
+
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+
+
+
+
+      static vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= (std::size_t)0x01;
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else
+        vtable = 0;
+    }
+
+
+
+
+    void move_assign(function2& f)
+    {
+      if (&f == this)
+        return;
+
+      { try {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } catch(...) {
+        vtable = 0;
+        throw;;
+      }
+      }
+    }
+  };
+
+  template<typename R , typename T0 , typename T1>
+  inline void swap(function2<
+                     R ,
+                     T0 , T1
+                   >& f1,
+                   function2<
+                     R ,
+                     T0 , T1
+                   >& f2)
+  {
+    f1.swap(f2);
+  }
+
+
+  template<typename R , typename T0 , typename T1>
+  typename function2<
+      R , T0 , T1>::result_type
+  inline
+  function2<R , T0 , T1>
+  ::operator()( T0 a0 , T1 a1) const
+  {
+    if (this->empty())
+      boost::throw_exception(bad_function_call());
+
+    return get_vtable()->invoker
+             (this->functor , a0 , a1);
+  }
+
+
+
+template<typename R , typename T0 , typename T1>
+  void operator==(const function2<
+                          R ,
+                          T0 , T1>&,
+                  const function2<
+                          R ,
+                          T0 , T1>&);
+template<typename R , typename T0 , typename T1>
+  void operator!=(const function2<
+                          R ,
+                          T0 , T1>&,
+                  const function2<
+                          R ,
+                          T0 , T1>& );
+# 1041 "/usr/include/boost-1_42/boost/function/function_template.hpp"
+template<typename R ,
+         typename T0 , typename T1>
+class function<R ( T0 , T1)>
+  : public function2<R , T0 , T1>
+{
+  typedef function2<R , T0 , T1> base_type;
+  typedef function self_type;
+
+  struct clear_type {};
+
+public:
+
+  function() : base_type() {}
+
+  template<typename Functor>
+  function(Functor f
+
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f)
+  {
+  }
+  template<typename Functor,typename Allocator>
+  function(Functor f, Allocator a
+
+           ,typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                          (is_integral<Functor>::value)>::value),
+                       int>::type = 0
+
+           ) :
+    base_type(f,a)
+  {
+  }
+
+
+  function(clear_type*) : base_type() {}
+
+
+  function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}
+
+  self_type& operator=(const self_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+  template<typename Functor>
+
+  typename enable_if_c<
+                            (boost::type_traits::ice_not<
+                         (is_integral<Functor>::value)>::value),
+                      self_type&>::type
+
+
+
+  operator=(Functor f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+
+
+  self_type& operator=(clear_type*)
+  {
+    this->clear();
+    return *this;
+  }
+
+
+  self_type& operator=(const base_type& f)
+  {
+    self_type(f).swap(*this);
+    return *this;
+  }
+};
+
+
+
+
+}
+# 24 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 2
+# 12 "/usr/include/boost-1_42/boost/function/function2.hpp" 2
+# 9 "/usr/include/boost-1_42/boost/python/object/function_object.hpp" 2
+
+
+
+
+namespace boost { namespace python {
+
+namespace objects
+{
+  api::object function_object(
+      py_function const& f
+      , python::detail::keyword_range const&);
+
+  api::object function_object(
+      py_function const& f
+      , python::detail::keyword_range const&);
+
+  api::object function_object(py_function const& f);
+
+
+
+
+
+  void add_to_namespace(
+      object const& name_space, char const* name, object const& attribute);
+
+  void add_to_namespace(
+      object const& name_space, char const* name, object const& attribute, char const* doc);
+}
+
+}}
+# 15 "/usr/include/boost-1_42/boost/python/make_function.hpp" 2
+
+
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+
+
+
+
+  template <class F, class CallPolicies, class Sig>
+  object make_function_aux(
+      F f
+      , CallPolicies const& p
+      , Sig const&
+      )
+  {
+      return objects::function_object(
+          detail::caller<F,CallPolicies,Sig>(f, p)
+      );
+  }
+
+
+
+
+
+  template <class F, class CallPolicies, class Sig, class NumKeywords>
+  object make_function_aux(
+      F f
+      , CallPolicies const& p
+      , Sig const&
+      , detail::keyword_range const& kw
+      , NumKeywords
+      )
+  {
+      enum { arity = mpl::size<Sig>::value - 1 };
+
+      typedef typename detail::error::more_keywords_than_function_arguments<
+          NumKeywords::value, arity
+          >::too_many_keywords assertion;
+
+      return objects::function_object(
+          detail::caller<F,CallPolicies,Sig>(f, p)
+        , kw);
+  }
+
+
+
+
+
+
+  template <class F, class CallPolicies, class Keywords>
+  object make_function_dispatch(F f, CallPolicies const& policies, Keywords const& kw, mpl::true_)
+  {
+      return detail::make_function_aux(
+          f
+        , policies
+        , detail::get_signature(f)
+        , kw.range()
+        , mpl::int_<Keywords::size>()
+      );
+  }
+
+  template <class F, class CallPolicies, class Signature>
+  object make_function_dispatch(F f, CallPolicies const& policies, Signature const& sig, mpl::false_)
+  {
+      return detail::make_function_aux(
+          f
+        , policies
+        , sig
+      );
+  }
+
+
+ }
+
+
+
+
+
+
+template <class F>
+object make_function(F f)
+{
+    return detail::make_function_aux(
+        f,default_call_policies(), detail::get_signature(f));
+}
+
+template <class F, class CallPolicies>
+object make_function(F f, CallPolicies const& policies)
+{
+    return detail::make_function_aux(
+        f, policies, detail::get_signature(f));
+}
+
+template <class F, class CallPolicies, class KeywordsOrSignature>
+object make_function(
+    F f
+  , CallPolicies const& policies
+  , KeywordsOrSignature const& keywords_or_signature)
+{
+    typedef typename
+        detail::is_reference_to_keywords<KeywordsOrSignature&>::type
+        is_kw;
+
+    return detail::make_function_dispatch(
+        f
+      , policies
+      , keywords_or_signature
+      , is_kw()
+    );
+}
+
+template <class F, class CallPolicies, class Keywords, class Signature>
+object make_function(
+    F f
+  , CallPolicies const& policies
+  , Keywords const& kw
+  , Signature const& sig
+ )
+{
+    return detail::make_function_aux(
+          f
+        , policies
+        , sig
+        , kw.range()
+        , mpl::int_<Keywords::size>()
+      );
+}
+
+
+}}
+# 16 "/usr/include/boost-1_42/boost/python/data_members.hpp" 2
+# 37 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+namespace boost { namespace python {
+# 46 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+namespace detail
+{
+
+
+
+  template <class Data, class Class>
+  struct member
+  {
+   public:
+      member(Data Class::*which) : m_which(which) {}
+
+      Data& operator()(Class& c) const
+      {
+          return c.*m_which;
+      }
+
+      void operator()(Class& c, typename value_arg<Data>::type d) const
+      {
+          c.*m_which = d;
+      }
+   private:
+      Data Class::*m_which;
+  };
+
+
+
+  template <class Data>
+  struct datum
+  {
+   public:
+      datum(Data *which) : m_which(which) {}
+
+      Data& operator()() const
+      {
+          return *m_which;
+      }
+
+      void operator()(typename value_arg<Data>::type d) const
+      {
+          *m_which = d;
+      }
+   private:
+      Data *m_which;
+  };
+# 102 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+  template <class T>
+  struct default_getter_by_ref
+      : mpl::and_<
+          mpl::bool_<
+              to_python_value<
+                  typename value_arg<T>::type
+              >::uses_registry
+          >
+        , indirect_traits::is_reference_to_class<
+              typename value_arg<T>::type
+          >
+       >
+  {
+  };
+# 125 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+  template <class T>
+  struct default_member_getter_policy
+    : mpl::if_<
+          default_getter_by_ref<T>
+        , return_internal_reference<>
+        , return_value_policy<return_by_value>
+      >
+  {};
+
+
+
+  template <class T>
+  struct default_datum_getter_policy
+    : mpl::if_<
+          default_getter_by_ref<T>
+        , return_value_policy<reference_existing_object>
+        , return_value_policy<return_by_value>
+      >
+  {};
+# 162 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+  template <class D, class Policies>
+  inline object make_getter(D* d, Policies const& policies, mpl::false_, int)
+  {
+      return python::make_function(
+          detail::datum<D>(d), policies, mpl::vector1<D&>()
+      );
+  }
+
+
+  template <class D>
+  inline object make_getter(D* d, not_specified, mpl::false_, long)
+  {
+      typedef typename default_datum_getter_policy<D>::type policies;
+      return detail::make_getter(d, policies(), mpl::false_(), 0);
+  }
+
+
+  template <class C, class D, class Policies>
+  inline object make_getter(D C::*pm, Policies const& policies, mpl::true_, int)
+  {
+
+
+
+      typedef C Class;
+
+      return python::make_function(
+          detail::member<D,Class>(pm)
+        , policies
+        , mpl::vector2<D&,Class&>()
+      );
+  }
+
+
+  template <class C, class D>
+  inline object make_getter(D C::*pm, not_specified, mpl::true_, long)
+  {
+      typedef typename default_member_getter_policy<D>::type policies;
+      return detail::make_getter(pm, policies(), mpl::true_(), 0);
+  }
+
+
+  template <class D, class P>
+  inline object make_getter(D& d, P& p, mpl::false_, ...)
+  {
+
+      return detail::make_getter(&d, p, mpl::false_(), 0L);
+  }
+# 219 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+  template <class D, class Policies>
+  inline object make_setter(D* p, Policies const& policies, mpl::false_, int)
+  {
+      return python::make_function(
+          detail::datum<D>(p), policies, mpl::vector2<void,D const&>()
+      );
+  }
+
+
+  template <class C, class D, class Policies>
+  inline object make_setter(D C::*pm, Policies const& policies, mpl::true_, int)
+  {
+      return python::make_function(
+          detail::member<D,C>(pm)
+        , policies
+        , mpl::vector3<void, C&, D const&>()
+      );
+  }
+
+
+  template <class D, class Policies>
+  inline object make_setter(D& x, Policies const& policies, mpl::false_, ...)
+  {
+      return detail::make_setter(&x, policies, mpl::false_(), 0L);
+  }
+}
+# 253 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+template <class D, class Policies>
+inline object make_getter(D& d, Policies const& policies)
+{
+    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
+}
+
+template <class D, class Policies>
+inline object make_getter(D const& d, Policies const& policies)
+{
+    return detail::make_getter(d, policies, is_member_pointer<D>(), 0L);
+}
+
+template <class D>
+inline object make_getter(D& x)
+{
+    detail::not_specified policy
+        = detail::not_specified();
+    return detail::make_getter(x, policy, is_member_pointer<D>(), 0L);
+}
+
+
+template <class D>
+inline object make_getter(D const& d)
+{
+    detail::not_specified policy
+        = detail::not_specified();
+    return detail::make_getter(d, policy, is_member_pointer<D>(), 0L);
+}
+# 290 "/usr/include/boost-1_42/boost/python/data_members.hpp"
+template <class D, class Policies>
+inline object make_setter(D& x, Policies const& policies)
+{
+    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
+}
+
+template <class D, class Policies>
+inline object make_setter(D const& x, Policies const& policies)
+{
+    return detail::make_setter(x, policies, is_member_pointer<D>(), 0);
+}
+
+template <class D>
+inline object make_setter(D& x)
+{
+    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
+}
+
+
+template <class D>
+inline object make_setter(D const& x)
+{
+    return detail::make_setter(x, default_call_policies(), is_member_pointer<D>(), 0);
+}
+
+
+}}
+# 18 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/init.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/init.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 33 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+namespace boost { namespace python { namespace objects {
+
+template <int nargs> struct make_holder;
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<0>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+# 82 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+        static void execute(
+
+
+
+            PyObject *p
+
+            )
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p ))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<1>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<2>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<3>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<4>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<5>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<6>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<7>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<8>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<9>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+
+
+        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<10>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+
+
+        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
+
+
+        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<11>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+
+
+        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
+
+
+        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;
+
+
+        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<12>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+
+
+        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
+
+
+        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;
+
+
+        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;
+
+
+        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<13>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+
+
+        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
+
+
+        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;
+
+
+        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;
+
+
+        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;
+
+
+        typedef typename mpl::deref<iter12>::type t12; typedef typename forward<t12>::type f12; typedef typename mpl::next<iter12>::type iter13;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11 , t12 a12)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11) , f12(a12)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<14>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+
+
+        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
+
+
+        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;
+
+
+        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;
+
+
+        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;
+
+
+        typedef typename mpl::deref<iter12>::type t12; typedef typename forward<t12>::type f12; typedef typename mpl::next<iter12>::type iter13;
+
+
+        typedef typename mpl::deref<iter13>::type t13; typedef typename forward<t13>::type f13; typedef typename mpl::next<iter13>::type iter14;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11 , t12 a12 , t13 a13)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11) , f12(a12) , f13(a13)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 56 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+
+
+
+
+template <>
+struct make_holder<15>
+{
+    template <class Holder, class ArgList>
+    struct apply
+    {
+
+
+
+
+        typedef typename mpl::begin<ArgList>::type iter0;
+# 79 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        typedef typename mpl::deref<iter0>::type t0; typedef typename forward<t0>::type f0; typedef typename mpl::next<iter0>::type iter1;
+
+
+        typedef typename mpl::deref<iter1>::type t1; typedef typename forward<t1>::type f1; typedef typename mpl::next<iter1>::type iter2;
+
+
+        typedef typename mpl::deref<iter2>::type t2; typedef typename forward<t2>::type f2; typedef typename mpl::next<iter2>::type iter3;
+
+
+        typedef typename mpl::deref<iter3>::type t3; typedef typename forward<t3>::type f3; typedef typename mpl::next<iter3>::type iter4;
+
+
+        typedef typename mpl::deref<iter4>::type t4; typedef typename forward<t4>::type f4; typedef typename mpl::next<iter4>::type iter5;
+
+
+        typedef typename mpl::deref<iter5>::type t5; typedef typename forward<t5>::type f5; typedef typename mpl::next<iter5>::type iter6;
+
+
+        typedef typename mpl::deref<iter6>::type t6; typedef typename forward<t6>::type f6; typedef typename mpl::next<iter6>::type iter7;
+
+
+        typedef typename mpl::deref<iter7>::type t7; typedef typename forward<t7>::type f7; typedef typename mpl::next<iter7>::type iter8;
+
+
+        typedef typename mpl::deref<iter8>::type t8; typedef typename forward<t8>::type f8; typedef typename mpl::next<iter8>::type iter9;
+
+
+        typedef typename mpl::deref<iter9>::type t9; typedef typename forward<t9>::type f9; typedef typename mpl::next<iter9>::type iter10;
+
+
+        typedef typename mpl::deref<iter10>::type t10; typedef typename forward<t10>::type f10; typedef typename mpl::next<iter10>::type iter11;
+
+
+        typedef typename mpl::deref<iter11>::type t11; typedef typename forward<t11>::type f11; typedef typename mpl::next<iter11>::type iter12;
+
+
+        typedef typename mpl::deref<iter12>::type t12; typedef typename forward<t12>::type f12; typedef typename mpl::next<iter12>::type iter13;
+
+
+        typedef typename mpl::deref<iter13>::type t13; typedef typename forward<t13>::type f13; typedef typename mpl::next<iter13>::type iter14;
+
+
+        typedef typename mpl::deref<iter14>::type t14; typedef typename forward<t14>::type f14; typedef typename mpl::next<iter14>::type iter15;
+# 80 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+        static void execute(
+
+
+
+            PyObject *p
+
+            , t0 a0 , t1 a1 , t2 a2 , t3 a3 , t4 a4 , t5 a5 , t6 a6 , t7 a7 , t8 a8 , t9 a9 , t10 a10 , t11 a11 , t12 a12 , t13 a13 , t14 a14)
+        {
+            typedef instance<Holder> instance_t;
+
+            void* memory = Holder::allocate(p, __builtin_offsetof (instance_t, storage), sizeof(Holder));
+            try {
+                (new (memory) Holder(
+                    p , f0(a0) , f1(a1) , f2(a2) , f3(a3) , f4(a4) , f5(a5) , f6(a6) , f7(a7) , f8(a8) , f9(a9) , f10(a10) , f11(a11) , f12(a12) , f13(a13) , f14(a14)))->install(p);
+            }
+            catch(...) {
+                Holder::deallocate(p, memory);
+                throw;
+            }
+        }
+    };
+};
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 2
+
+
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp" 2
+
+
+
+
+namespace boost { namespace python { namespace detail {
+# 25 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp"
+template <class F, class Policies>
+object make_keyword_range_function(
+    F f
+  , Policies const& policies
+  , keyword_range const& kw)
+{
+    return detail::make_function_aux(
+        f, policies, detail::get_signature(f), kw, mpl::int_<0>());
+}
+
+template <class F, class Policies, class Signature>
+object make_keyword_range_function(
+    F f
+  , Policies const& policies
+  , keyword_range const& kw
+  , Signature const& sig)
+{
+    return detail::make_function_aux(
+        f, policies, sig, kw, mpl::int_<0>());
+}
+# 53 "/usr/include/boost-1_42/boost/python/detail/make_keyword_range_fn.hpp"
+template <class ArgList, class Arity, class Holder, class CallPolicies>
+object make_keyword_range_constructor(
+    CallPolicies const& policies
+    , detail::keyword_range const& kw
+    , Holder* = 0
+    , ArgList* = 0, Arity* = 0)
+{
+
+
+
+    return detail::make_keyword_range_function(
+        objects::make_holder<Arity::value>
+            ::template apply<Holder,ArgList>::execute
+        , policies
+        , kw);
+}
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/init.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/empty.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/empty.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/empty_impl.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/empty_impl.hpp"
+namespace boost { namespace mpl {
+
+
+
+
+template< typename Tag >
+struct empty_impl
+{
+    template< typename Sequence > struct apply
+        : is_same<
+              typename begin<Sequence>::type
+            , typename end<Sequence>::type
+            >
+    {
+    };
+};
+
+ template<> struct empty_impl<non_sequence_tag> {};
+
+}}
+# 20 "/usr/include/boost-1_42/boost/mpl/empty.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    >
+struct empty
+    : empty_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+   
+};
+
+template<> struct empty< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : empty< T1 > { }; }; template< typename Tag > struct lambda< empty< na > , Tag , int_<-1> > { typedef false_ is_le; typedef empty< na > result_; typedef empty< na > type; }; namespace aux { template< typename T1 > struct template_arity< empty< T1 > > : int_<1> { }; template<> struct template_arity< empty< na > > : int_<-1> { }; }
+
+}}
+# 24 "/usr/include/boost-1_42/boost/python/init.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/joint_view.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/joint_view.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/lambda_spec.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+template<
+      typename Iterator1
+    , typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter
+{
+    typedef Iterator1 base;
+    typedef forward_iterator_tag category;
+};
+
+template<
+      typename LastIterator1
+    , typename Iterator2
+    >
+struct joint_iter<LastIterator1,LastIterator1,Iterator2>
+{
+    typedef Iterator2 base;
+    typedef forward_iterator_tag category;
+};
+
+
+template< typename I1, typename L1, typename I2 >
+struct deref< joint_iter<I1,L1,I2> >
+{
+    typedef typename joint_iter<I1,L1,I2>::base base_;
+    typedef typename deref<base_>::type type;
+};
+
+template< typename I1, typename L1, typename I2 >
+struct next< joint_iter<I1,L1,I2> >
+{
+    typedef joint_iter< typename mpl::next<I1>::type,L1,I2 > type;
+};
+
+template< typename L1, typename I2 >
+struct next< joint_iter<L1,L1,I2> >
+{
+    typedef joint_iter< L1,L1,typename mpl::next<I2>::type > type;
+};
+# 116 "/usr/include/boost-1_42/boost/mpl/aux_/joint_iter.hpp"
+template< typename T1 , typename T2 , typename T3 , typename Tag > struct lambda< joint_iter< T1 , T2 , T3 > , Tag , int_<3> > { typedef false_ is_le; typedef joint_iter< T1 , T2 , T3 > result_; typedef result_ type; };
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/joint_view.hpp" 2
+
+
+
+
+
+namespace boost { namespace mpl {
+
+namespace aux {
+struct joint_view_tag;
+}
+
+template<>
+struct size_impl< aux::joint_view_tag >
+{
+    template < typename JointView > struct apply
+      : plus<
+            size<typename JointView::sequence1_>
+          , size<typename JointView::sequence2_>
+          >
+    {};
+};
+
+template<
+      typename Sequence1_ = na
+    , typename Sequence2_ = na
+    >
+struct joint_view
+{
+    typedef typename mpl::begin<Sequence1_>::type first1_;
+    typedef typename mpl::end<Sequence1_>::type last1_;
+    typedef typename mpl::begin<Sequence2_>::type first2_;
+    typedef typename mpl::end<Sequence2_>::type last2_;
+
+
+    typedef Sequence1_ sequence1_;
+    typedef Sequence2_ sequence2_;
+
+    typedef joint_view type;
+    typedef aux::joint_view_tag tag;
+    typedef joint_iter<first1_,last1_,first2_> begin;
+    typedef joint_iter<last1_,last1_,last2_> end;
+};
+
+template<> struct joint_view< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : joint_view< T1 , T2 > { }; }; template< typename Tag > struct lambda< joint_view< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef joint_view< na , na > result_; typedef joint_view< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< joint_view< T1 , T2 > > : int_<2> { }; template<> struct template_arity< joint_view< na , na > > : int_<-1> { }; }
+
+}}
+# 28 "/usr/include/boost-1_42/boost/python/init.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/back.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/back.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/back_impl.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/back_impl.hpp"
+namespace boost { namespace mpl {
+
+
+
+
+
+template< typename Tag >
+struct back_impl
+{
+    template< typename Sequence > struct apply
+    {
+        typedef typename end<Sequence>::type end_;
+        typedef typename prior<end_>::type last_;
+        typedef typename deref<last_>::type type;
+    };
+};
+
+ template<> struct back_impl<non_sequence_tag> {};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/back.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    >
+struct back
+    : back_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+   
+};
+
+template<> struct back< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : back< T1 > { }; }; template< typename Tag > struct lambda< back< na > , Tag , int_<-1> > { typedef false_ is_le; typedef back< na > result_; typedef back< na > type; }; namespace aux { template< typename T1 > struct template_arity< back< T1 > > : int_<1> { }; template<> struct template_arity< back< na > > : int_<-1> { }; }
+
+}}
+# 29 "/usr/include/boost-1_42/boost/python/init.hpp" 2
+# 55 "/usr/include/boost-1_42/boost/python/init.hpp"
+namespace boost { namespace python {
+
+template < class T0 = mpl::void_ , class T1 = mpl::void_ , class T2 = mpl::void_ , class T3 = mpl::void_ , class T4 = mpl::void_ , class T5 = mpl::void_ , class T6 = mpl::void_ , class T7 = mpl::void_ , class T8 = mpl::void_ , class T9 = mpl::void_ , class T10 = mpl::void_ , class T11 = mpl::void_ , class T12 = mpl::void_ , class T13 = mpl::void_ , class T14 = mpl::void_ >
+class init;
+
+
+template < class T0 = mpl::void_ , class T1 = mpl::void_ , class T2 = mpl::void_ , class T3 = mpl::void_ , class T4 = mpl::void_ , class T5 = mpl::void_ , class T6 = mpl::void_ , class T7 = mpl::void_ , class T8 = mpl::void_ , class T9 = mpl::void_ , class T10 = mpl::void_ , class T11 = mpl::void_ , class T12 = mpl::void_ , class T13 = mpl::void_ , class T14 = mpl::void_ >
+struct optional;
+
+namespace detail
+{
+  namespace error
+  {
+    template <int keywords, int init_args>
+    struct more_keywords_than_init_arguments
+    {
+        typedef char too_many_keywords[init_args - keywords >= 0 ? 1 : -1];
+    };
+  }
+# 101 "/usr/include/boost-1_42/boost/python/init.hpp"
+    template <class T>
+    struct is_optional
+      : mpl::false_
+    {};
+
+    template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+    struct is_optional<optional< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> >
+      : mpl::true_
+    {};
+
+
+
+  template <int NDefaults>
+  struct define_class_init_helper;
+
+}
+
+template <class DerivedT>
+struct init_base : def_visitor<DerivedT>
+{
+    init_base(char const* doc_, detail::keyword_range const& keywords_)
+        : m_doc(doc_), m_keywords(keywords_)
+    {}
+
+    init_base(char const* doc_)
+        : m_doc(doc_)
+    {}
+
+    DerivedT const& derived() const
+    {
+        return *static_cast<DerivedT const*>(this);
+    }
+
+    char const* doc_string() const
+    {
+        return m_doc;
+    }
+
+    detail::keyword_range const& keywords() const
+    {
+        return m_keywords;
+    }
+
+    static default_call_policies call_policies()
+    {
+        return default_call_policies();
+    }
+
+ private:
+# 164 "/usr/include/boost-1_42/boost/python/init.hpp"
+    template <class classT>
+    void visit(classT& cl) const
+    {
+        typedef typename DerivedT::signature signature;
+        typedef typename DerivedT::n_arguments n_arguments;
+        typedef typename DerivedT::n_defaults n_defaults;
+
+        detail::define_class_init_helper<n_defaults::value>::apply(
+            cl
+          , derived().call_policies()
+          , signature()
+          , n_arguments()
+          , derived().doc_string()
+          , derived().keywords());
+    }
+
+    friend class python::def_visitor_access;
+
+ private:
+    char const* m_doc;
+    detail::keyword_range m_keywords;
+};
+
+template <class CallPoliciesT, class InitT>
+class init_with_call_policies
+    : public init_base<init_with_call_policies<CallPoliciesT, InitT> >
+{
+    typedef init_base<init_with_call_policies<CallPoliciesT, InitT> > base;
+ public:
+    typedef typename InitT::n_arguments n_arguments;
+    typedef typename InitT::n_defaults n_defaults;
+    typedef typename InitT::signature signature;
+
+    init_with_call_policies(
+        CallPoliciesT const& policies_
+        , char const* doc_
+        , detail::keyword_range const& keywords
+        )
+        : base(doc_, keywords)
+        , m_policies(policies_)
+    {}
+
+    CallPoliciesT const& call_policies() const
+    {
+        return this->m_policies;
+    }
+
+ private:
+    CallPoliciesT m_policies;
+};
+
+
+
+
+namespace detail
+{
+  template <class S>
+  struct drop1
+    : mpl::iterator_range<
+          typename mpl::begin<S>::type
+        , typename mpl::prior<
+              typename mpl::end<S>::type
+          >::type
+      >
+  {};
+}
+
+template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+class init : public init_base<init< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> >
+{
+    typedef init_base<init< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> > base;
+ public:
+    typedef init< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> self_t;
+
+    init(char const* doc_ = 0)
+        : base(doc_)
+    {
+    }
+
+    template <std::size_t N>
+    init(char const* doc_, detail::keywords<N> const& kw)
+        : base(doc_, kw.range())
+    {
+        typedef typename detail::error::more_keywords_than_init_arguments<
+            N, n_arguments::value + 1
+            >::too_many_keywords assertion;
+    }
+
+    template <std::size_t N>
+    init(detail::keywords<N> const& kw, char const* doc_ = 0)
+        : base(doc_, kw.range())
+    {
+        typedef typename detail::error::more_keywords_than_init_arguments<
+            N, n_arguments::value + 1
+            >::too_many_keywords assertion;
+    }
+
+    template <class CallPoliciesT>
+    init_with_call_policies<CallPoliciesT, self_t>
+    operator[](CallPoliciesT const& policies) const
+    {
+        return init_with_call_policies<CallPoliciesT, self_t>(
+            policies, this->doc_string(), this->keywords());
+    }
+
+    typedef detail::type_list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14> signature_;
+
+    typedef detail::is_optional<
+        typename mpl::eval_if<
+            mpl::empty<signature_>
+          , mpl::false_
+          , mpl::back<signature_>
+        >::type
+    > back_is_optional;
+
+    typedef typename mpl::eval_if<
+        back_is_optional
+      , mpl::back<signature_>
+      , mpl::vector0<>
+    >::type optional_args;
+
+    typedef typename mpl::eval_if<
+        back_is_optional
+      , mpl::if_<
+            mpl::empty<optional_args>
+          , detail::drop1<signature_>
+          , mpl::joint_view<
+                detail::drop1<signature_>
+              , optional_args
+            >
+        >
+      , signature_
+    >::type signature;
+
+
+
+
+    typedef mpl::size<optional_args> n_defaults;
+    typedef mpl::size<signature> n_arguments;
+};
+# 312 "/usr/include/boost-1_42/boost/python/init.hpp"
+template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6 , class T7 , class T8 , class T9 , class T10 , class T11 , class T12 , class T13 , class T14>
+struct optional
+    : detail::type_list< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14>
+{
+};
+
+namespace detail
+{
+  template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
+  inline void def_init_aux(
+      ClassT& cl
+      , Signature const&
+      , NArgs
+      , CallPoliciesT const& policies
+      , char const* doc
+      , detail::keyword_range const& keywords_
+      )
+  {
+      cl.def(
+          "__init__"
+        , detail::make_keyword_range_constructor<Signature,NArgs>(
+              policies
+            , keywords_
+            , (typename ClassT::metadata::holder*)0
+          )
+        , doc
+      );
+  }
+# 353 "/usr/include/boost-1_42/boost/python/init.hpp"
+  template <int NDefaults>
+  struct define_class_init_helper
+  {
+
+      template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
+      static void apply(
+          ClassT& cl
+          , CallPoliciesT const& policies
+          , Signature const& args
+          , NArgs
+          , char const* doc
+          , detail::keyword_range keywords)
+      {
+          detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords);
+
+          if (keywords.second > keywords.first)
+              --keywords.second;
+
+          typedef typename mpl::prior<NArgs>::type next_nargs;
+          define_class_init_helper<NDefaults-1>::apply(
+              cl, policies, Signature(), next_nargs(), doc, keywords);
+      }
+  };
+# 387 "/usr/include/boost-1_42/boost/python/init.hpp"
+  template <>
+  struct define_class_init_helper<0> {
+
+      template <class ClassT, class CallPoliciesT, class Signature, class NArgs>
+      static void apply(
+          ClassT& cl
+        , CallPoliciesT const& policies
+        , Signature const& args
+        , NArgs
+        , char const* doc
+        , detail::keyword_range const& keywords)
+      {
+          detail::def_init_aux(cl, args, NArgs(), policies, doc, keywords);
+      }
+  };
+}
+
+}}
+# 21 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 1
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_from_python.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/python/converter/shared_ptr_from_python.hpp"
+namespace boost { namespace python { namespace converter {
+
+template <class T>
+struct shared_ptr_from_python
+{
+    shared_ptr_from_python()
+    {
+        converter::registry::insert(&convertible, &construct, type_id<shared_ptr<T> >()
+
+                      , &converter::expected_from_python_type_direct<T>::get_pytype
+
+                      );
+    }
+
+ private:
+    static void* convertible(PyObject* p)
+    {
+        if (p == (&_Py_NoneStruct))
+            return p;
+
+        return converter::get_lvalue_from_python(p, registered<T>::converters);
+    }
+
+    static void construct(PyObject* source, rvalue_from_python_stage1_data* data)
+    {
+        void* const storage = ((converter::rvalue_from_python_storage<shared_ptr<T> >*)data)->storage.bytes;
+
+        if (data->convertible == source)
+            new (storage) shared_ptr<T>();
+        else
+        {
+            boost::shared_ptr<void> hold_convertible_ref_count(
+              (void*)0, shared_ptr_deleter(handle<>(borrowed(source))) );
+
+            new (storage) shared_ptr<T>(
+                hold_convertible_ref_count,
+                static_cast<T*>(data->convertible));
+        }
+
+        data->convertible = storage;
+    }
+};
+
+}}}
+# 7 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/object/inheritance.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/object/inheritance.hpp"
+namespace boost { namespace python { namespace objects {
+
+typedef type_info class_id;
+using python::type_id;
+
+
+typedef std::pair<void*,class_id> dynamic_id_t;
+typedef dynamic_id_t (*dynamic_id_function)(void*);
+
+ void register_dynamic_id_aux(
+    class_id static_id, dynamic_id_function get_dynamic_id);
+
+ void add_cast(
+    class_id src_t, class_id dst_t, void* (*cast)(void*), bool is_downcast);
+# 37 "/usr/include/boost-1_42/boost/python/object/inheritance.hpp"
+template <class T>
+struct polymorphic_id_generator
+{
+    static dynamic_id_t execute(void* p_)
+    {
+        T* p = static_cast<T*>(p_);
+        return std::make_pair(dynamic_cast<void*>(p), class_id(typeid(*p)));
+    }
+};
+
+
+template <class T>
+struct non_polymorphic_id_generator
+{
+    static dynamic_id_t execute(void* p_)
+    {
+        return std::make_pair(p_, python::type_id<T>());
+    }
+};
+
+
+template <class T>
+struct dynamic_id_generator
+  : mpl::if_<
+        boost::is_polymorphic<T>
+        , boost::python::objects::polymorphic_id_generator<T>
+        , boost::python::objects::non_polymorphic_id_generator<T>
+    >
+{};
+
+
+
+template <class T>
+void register_dynamic_id(T* = 0)
+{
+    typedef typename dynamic_id_generator<T>::type generator;
+    register_dynamic_id_aux(
+        python::type_id<T>(), &generator::execute);
+}
+
+
+
+
+
+
+
+template <class Source, class Target>
+struct dynamic_cast_generator
+{
+    static void* execute(void* source)
+    {
+        return dynamic_cast<Target*>(
+            static_cast<Source*>(source));
+    }
+
+};
+
+template <class Source, class Target>
+struct implicit_cast_generator
+{
+    static void* execute(void* source)
+    {
+        Target* result = static_cast<Source*>(source);
+        return result;
+    }
+};
+
+template <class Source, class Target>
+struct cast_generator
+  : mpl::if_<
+        is_base_and_derived<Target,Source>
+      , implicit_cast_generator<Source,Target>
+      , dynamic_cast_generator<Source,Target>
+    >
+{
+};
+
+template <class Source, class Target>
+inline void register_conversion(
+    bool is_downcast = ::boost::is_base_and_derived<Source,Target>::value
+
+    , Source* = 0, Target* = 0)
+{
+    typedef typename cast_generator<Source,Target>::type generator;
+
+    add_cast(
+        python::type_id<Source>()
+      , python::type_id<Target>()
+      , &generator::execute
+      , is_downcast
+    );
+}
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/class_wrapper.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/as_to_python_function.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/converter/as_to_python_function.hpp"
+namespace boost { namespace python { namespace converter {
+
+
+
+template <class T, class ToPython>
+struct as_to_python_function
+{
+
+
+
+
+    template <class U>
+    static void convert_function_must_take_value_or_const_reference(U(*)(T), int, T* = 0) {}
+    template <class U>
+    static void convert_function_must_take_value_or_const_reference(U(*)(T const&), long ...) {}
+
+    static PyObject* convert(void const* x)
+    {
+        convert_function_must_take_value_or_const_reference(&ToPython::convert, 1L);
+# 40 "/usr/include/boost-1_42/boost/python/converter/as_to_python_function.hpp"
+        return ToPython::convert(*const_cast<T*>(static_cast<T const*>(x)));
+    }
+
+    static PyTypeObject const * get_pytype() { return ToPython::get_pytype(); }
+
+};
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp" 2
+
+
+
+
+
+namespace boost { namespace python {
+# 47 "/usr/include/boost-1_42/boost/python/to_python_converter.hpp"
+template < class T, class Conversion, bool has_get_pytype=false >
+struct to_python_converter
+{
+
+
+
+
+
+    typedef boost::mpl::bool_<has_get_pytype> HasGetPytype;
+
+
+    static PyTypeObject const* get_pytype_1(boost::mpl::true_ *)
+    {
+        return Conversion::get_pytype();
+    }
+
+    static PyTypeObject const* get_pytype_1(boost::mpl::false_ *)
+    {
+        return 0;
+    }
+    static PyTypeObject const* get_pytype_impl()
+    {
+        return get_pytype_1((HasGetPytype*)0);
+    }
+
+
+    to_python_converter();
+};
+
+
+
+
+
+template <class T, class Conversion ,bool has_get_pytype>
+to_python_converter<T,Conversion, has_get_pytype>::to_python_converter()
+{
+    typedef converter::as_to_python_function<
+        T, Conversion
+        > normalized;
+
+    converter::registry::insert(
+        &normalized::convert
+        , type_id<T>()
+
+        , &get_pytype_impl
+
+        );
+}
+
+}}
+# 9 "/usr/include/boost-1_42/boost/python/object/class_wrapper.hpp" 2
+
+
+
+
+
+namespace boost { namespace python { namespace objects {
+# 23 "/usr/include/boost-1_42/boost/python/object/class_wrapper.hpp"
+template <class Src, class MakeInstance>
+struct class_cref_wrapper
+    : to_python_converter<Src,class_cref_wrapper<Src,MakeInstance> ,true>
+{
+    static PyObject* convert(Src const& x)
+    {
+        return MakeInstance::execute(boost::ref(x));
+    }
+
+    static PyTypeObject const *get_pytype() { return converter::registered_pytype_direct<Src>::get_pytype(); }
+
+};
+
+template <class Src, class MakeInstance>
+struct class_value_wrapper
+    : to_python_converter<Src,class_value_wrapper<Src,MakeInstance> ,true>
+{
+    static PyObject* convert(Src x)
+    {
+        return MakeInstance::execute(x);
+    }
+
+    static PyTypeObject const *get_pytype() { return MakeInstance::get_pytype(); }
+
+};
+
+}}}
+# 10 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder_fwd.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace objects {
+
+struct no_back_reference;
+
+template <class CallbackType = no_back_reference> struct value_holder_generator;
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/wrapper.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/override.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/extract.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/python/extract.hpp"
+namespace boost { namespace python {
+
+namespace api
+{
+  class object;
+}
+
+namespace converter
+{
+  template <class Ptr>
+  struct extract_pointer
+  {
+      typedef Ptr result_type;
+      extract_pointer(PyObject*);
+
+      bool check() const;
+      Ptr operator()() const;
+
+   private:
+      PyObject* m_source;
+      void* m_result;
+  };
+
+  template <class Ref>
+  struct extract_reference
+  {
+      typedef Ref result_type;
+      extract_reference(PyObject*);
+
+      bool check() const;
+      Ref operator()() const;
+
+   private:
+      PyObject* m_source;
+      void* m_result;
+  };
+
+  template <class T>
+  struct extract_rvalue : private noncopyable
+  {
+      typedef typename mpl::if_<
+          python::detail::copy_ctor_mutates_rhs<T>
+        , T&
+        , typename call_traits<T>::param_type
+      >::type result_type;
+
+      extract_rvalue(PyObject*);
+
+      bool check() const;
+      result_type operator()() const;
+   private:
+      PyObject* m_source;
+      mutable rvalue_from_python_data<T> m_data;
+  };
+
+  template <class T>
+  struct extract_object_manager
+  {
+      typedef T result_type;
+      extract_object_manager(PyObject*);
+
+      bool check() const;
+      result_type operator()() const;
+   private:
+      PyObject* m_source;
+  };
+
+  template <class T>
+  struct select_extract
+  {
+      static const bool obj_mgr = is_object_manager<T>::value
+                                                      ;
+
+      static const bool ptr = is_pointer<T>::value
+                                           ;
+
+      static const bool ref = is_reference<T>::value
+                                             ;
+
+      typedef typename mpl::if_c<
+          obj_mgr
+          , extract_object_manager<T>
+          , typename mpl::if_c<
+              ptr
+              , extract_pointer<T>
+              , typename mpl::if_c<
+                  ref
+                  , extract_reference<T>
+                  , extract_rvalue<T>
+                >::type
+            >::type
+         >::type type;
+  };
+}
+
+template <class T>
+struct extract
+    : converter::select_extract<T>::type
+{
+ private:
+    typedef typename converter::select_extract<T>::type base;
+ public:
+    typedef typename base::result_type result_type;
+
+    operator result_type() const
+    {
+        return (*this)();
+    }
+
+    extract(PyObject*);
+    extract(api::object const&);
+};
+
+
+
+
+template <class T>
+inline extract<T>::extract(PyObject* o)
+    : base(o)
+{
+}
+
+template <class T>
+inline extract<T>::extract(api::object const& o)
+    : base(o.ptr())
+{
+}
+
+namespace converter
+{
+  template <class T>
+  inline extract_rvalue<T>::extract_rvalue(PyObject* x)
+      : m_source(x)
+      , m_data(
+          (rvalue_from_python_stage1)(x, registered<T>::converters)
+          )
+  {
+  }
+
+  template <class T>
+  inline bool
+  extract_rvalue<T>::check() const
+  {
+      return m_data.stage1.convertible;
+  }
+
+  template <class T>
+  inline typename extract_rvalue<T>::result_type
+  extract_rvalue<T>::operator()() const
+  {
+      return *(T*)(
+
+          m_data.stage1.convertible == m_data.storage.bytes
+             ? m_data.storage.bytes
+             : (rvalue_from_python_stage2)(m_source, m_data.stage1, registered<T>::converters)
+          );
+  }
+
+  template <class Ref>
+  inline extract_reference<Ref>::extract_reference(PyObject* obj)
+      : m_source(obj)
+      , m_result(
+          (get_lvalue_from_python)(obj, registered<Ref>::converters)
+          )
+  {
+  }
+
+  template <class Ref>
+  inline bool extract_reference<Ref>::check() const
+  {
+      return m_result != 0;
+  }
+
+  template <class Ref>
+  inline Ref extract_reference<Ref>::operator()() const
+  {
+      if (m_result == 0)
+          (throw_no_reference_from_python)(m_source, registered<Ref>::converters);
+
+      return python::detail::void_ptr_to_reference(m_result, (Ref(*)())0);
+  }
+
+  template <class Ptr>
+  inline extract_pointer<Ptr>::extract_pointer(PyObject* obj)
+      : m_source(obj)
+      , m_result(
+          obj == (&_Py_NoneStruct) ? 0 : (get_lvalue_from_python)(obj, registered_pointee<Ptr>::converters)
+          )
+  {
+  }
+
+  template <class Ptr>
+  inline bool extract_pointer<Ptr>::check() const
+  {
+      return m_source == (&_Py_NoneStruct) || m_result != 0;
+  }
+
+  template <class Ptr>
+  inline Ptr extract_pointer<Ptr>::operator()() const
+  {
+      if (m_result == 0 && m_source != (&_Py_NoneStruct))
+          (throw_no_pointer_from_python)(m_source, registered_pointee<Ptr>::converters);
+
+      return Ptr(m_result);
+  }
+
+  template <class T>
+  inline extract_object_manager<T>::extract_object_manager(PyObject* obj)
+      : m_source(obj)
+  {
+  }
+
+  template <class T>
+  inline bool extract_object_manager<T>::check() const
+  {
+      return object_manager_traits<T>::check(m_source);
+  }
+
+  template <class T>
+  inline T extract_object_manager<T>::operator()() const
+  {
+      return T(
+          object_manager_traits<T>::adopt(python::incref(m_source))
+          );
+  }
+}
+
+}}
+# 14 "/usr/include/boost-1_42/boost/python/override.hpp" 2
+# 24 "/usr/include/boost-1_42/boost/python/override.hpp"
+namespace boost { namespace python {
+
+class override;
+
+namespace detail
+{
+  class wrapper_base;
+
+
+  class method_result
+  {
+   private:
+      friend class boost::python::override;
+      explicit method_result(PyObject* x)
+        : m_obj(x)
+      {}
+
+   public:
+      template <class T>
+      operator T()
+      {
+          converter::return_from_python<T> converter;
+          return converter(m_obj.release());
+      }
+# 62 "/usr/include/boost-1_42/boost/python/override.hpp"
+      template <class T>
+      operator T&() const
+      {
+          converter::return_from_python<T&> converter;
+          return converter(const_cast<handle<>&>(m_obj).release());
+      }
+
+
+      template <class T>
+      T as(type<T>* = 0)
+      {
+          converter::return_from_python<T> converter;
+          return converter(m_obj.release());
+      }
+
+      template <class T>
+      T unchecked(type<T>* = 0)
+      {
+          return extract<T>(m_obj)();
+      }
+   private:
+      mutable handle<> m_obj;
+  };
+}
+
+class override : public object
+{
+ private:
+    friend class detail::wrapper_base;
+    override(handle<> x)
+      : object(x)
+    {}
+
+ public:
+    detail::method_result
+    operator()() const
+    {
+        detail::method_result x(
+            PyEval_CallFunction(
+                this->ptr()
+              , const_cast<char*>("()")
+            ));
+        return x;
+    }
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 52 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0
+    >
+detail::method_result
+operator()( A0 const& a0 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" ")")
+            , converter::arg_to_python<A0>(a0).get()
+        ));
+    return x;
+}
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get()
+        ));
+    return x;
+}
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get()
+        ));
+    return x;
+}
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get()
+        ));
+    return x;
+}
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get()
+        ));
+    return x;
+}
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get()
+        ));
+    return x;
+}
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get()
+        ));
+    return x;
+}
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get()
+        ));
+    return x;
+}
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get()
+        ));
+    return x;
+}
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get()
+        ));
+    return x;
+}
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get()
+        ));
+    return x;
+}
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get()
+        ));
+    return x;
+}
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get()
+        ));
+    return x;
+}
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get()
+        ));
+    return x;
+}
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/override.hpp" 1
+# 123 "/usr/include/boost-1_42/boost/python/override.hpp"
+
+
+
+
+template <
+    class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14
+    >
+detail::method_result
+operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14 ) const
+{
+    detail::method_result x(
+        PyEval_CallFunction(
+            this->ptr()
+          , const_cast<char*>("(" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" "O" ")")
+            , converter::arg_to_python<A0>(a0).get() , converter::arg_to_python<A1>(a1).get() , converter::arg_to_python<A2>(a2).get() , converter::arg_to_python<A3>(a3).get() , converter::arg_to_python<A4>(a4).get() , converter::arg_to_python<A5>(a5).get() , converter::arg_to_python<A6>(a6).get() , converter::arg_to_python<A7>(a7).get() , converter::arg_to_python<A8>(a8).get() , converter::arg_to_python<A9>(a9).get() , converter::arg_to_python<A10>(a10).get() , converter::arg_to_python<A11>(a11).get() , converter::arg_to_python<A12>(a12).get() , converter::arg_to_python<A13>(a13).get() , converter::arg_to_python<A14>(a14).get()
+        ));
+    return x;
+}
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 112 "/usr/include/boost-1_42/boost/python/override.hpp" 2
+
+
+};
+
+}}
+# 9 "/usr/include/boost-1_42/boost/python/wrapper.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/sfinae.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/wrapper.hpp" 2
+
+namespace boost { namespace python {
+
+template <class T>
+class wrapper : public detail::wrapper_base
+{
+ public:
+
+    typedef T _wrapper_wrapped_type_;
+
+ protected:
+    override get_override(char const* name) const
+    {
+        typedef detail::wrapper_base base;
+        converter::registration const& r
+            = converter::registered<T>::converters;
+        PyTypeObject* type = r.get_class_object();
+
+        return this->base::get_override(name, type);
+    }
+};
+
+}}
+# 16 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2
+# 34 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+namespace boost { namespace python { namespace objects {
+
+
+
+
+
+
+
+template <class Value>
+struct value_holder : instance_holder
+{
+    typedef Value held_type;
+    typedef Value value_type;
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+
+
+    value_holder(
+      PyObject* self )
+        : m_held(
+           
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0>
+
+    value_holder(
+      PyObject* self , A0 a0)
+        : m_held(
+            objects::do_unforward(a0,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 126 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+
+    value_holder(
+      PyObject* self , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
+        : m_held(
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
+            )
+    {
+        python::detail::initialize_wrapper(self, boost::addressof(this->m_held));
+    }
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 51 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2
+
+ private:
+    void* holds(type_info, bool null_ptr_only);
+
+    template <class T>
+    inline void* holds_wrapped(type_info dst_t, wrapper<T>*,T* p)
+    {
+        return python::type_id<T>() == dst_t ? p : 0;
+    }
+
+    inline void* holds_wrapped(type_info, ...)
+    {
+        return 0;
+    }
+ private:
+    Value m_held;
+};
+
+template <class Value, class Held>
+struct value_holder_back_reference : instance_holder
+{
+    typedef Held held_type;
+    typedef Value value_type;
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+
+
+    value_holder_back_reference(
+        PyObject* p )
+        : m_held(
+            p
+           
+            )
+    {
+    }
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0)
+            )
+    {
+    }
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0)
+            )
+    {
+    }
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0)
+            )
+    {
+    }
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0)
+            )
+    {
+    }
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0)
+            )
+    {
+    }
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0)
+            )
+    {
+    }
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0)
+            )
+    {
+    }
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0)
+            )
+    {
+    }
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0)
+            )
+    {
+    }
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0)
+            )
+    {
+    }
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0)
+            )
+    {
+    }
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0)
+            )
+    {
+    }
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0)
+            )
+    {
+    }
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0)
+            )
+    {
+    }
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 1
+# 150 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp"
+
+
+
+
+
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+
+    value_holder_back_reference(
+        PyObject* p , A0 a0 , A1 a1 , A2 a2 , A3 a3 , A4 a4 , A5 a5 , A6 a6 , A7 a7 , A8 a8 , A9 a9 , A10 a10 , A11 a11 , A12 a12 , A13 a13 , A14 a14)
+        : m_held(
+            p ,
+            objects::do_unforward(a0,0) , objects::do_unforward(a1,0) , objects::do_unforward(a2,0) , objects::do_unforward(a3,0) , objects::do_unforward(a4,0) , objects::do_unforward(a5,0) , objects::do_unforward(a6,0) , objects::do_unforward(a7,0) , objects::do_unforward(a8,0) , objects::do_unforward(a9,0) , objects::do_unforward(a10,0) , objects::do_unforward(a11,0) , objects::do_unforward(a12,0) , objects::do_unforward(a13,0) , objects::do_unforward(a14,0)
+            )
+    {
+    }
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 78 "/usr/include/boost-1_42/boost/python/object/value_holder.hpp" 2
+
+private:
+    void* holds(type_info, bool null_ptr_only);
+
+ private:
+    Held m_held;
+};
+
+
+
+template <class Value>
+void* value_holder<Value>::holds(type_info dst_t, bool )
+{
+    if (void* wrapped = holds_wrapped(dst_t, boost::addressof(m_held), boost::addressof(m_held)))
+        return wrapped;
+
+    type_info src_t = python::type_id<Value>();
+    return src_t == dst_t ? boost::addressof(m_held)
+        : find_static_type(boost::addressof(m_held), src_t, dst_t);
+}
+
+template <class Value, class Held>
+void* value_holder_back_reference<Value,Held>::holds(
+    type_info dst_t, bool )
+{
+    type_info src_t = python::type_id<Value>();
+    Value* x = &m_held;
+
+    if (dst_t == src_t)
+        return x;
+    else if (dst_t == python::type_id<Held>())
+        return &m_held;
+    else
+        return find_static_type(x, src_t, dst_t);
+}
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/has_back_reference.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/has_back_reference.hpp"
+namespace boost { namespace python {
+
+
+
+template <class T>
+struct has_back_reference
+  : mpl::false_
+{
+};
+
+
+}}
+# 19 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/for_each.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp" 1
+# 40 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp"
+namespace boost { namespace mpl {
+# 90 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp"
+template<
+      typename T = na
+    >
+struct is_sequence
+    : not_< is_same< typename begin<T>::type, void_ > >
+{
+   
+};
+# 108 "/usr/include/boost-1_42/boost/mpl/is_sequence.hpp"
+template<> struct is_sequence< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_sequence< T1 > { }; }; template< typename Tag > struct lambda< is_sequence< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_sequence< na > result_; typedef is_sequence< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_sequence< T1 > > : int_<1> { }; template<> struct template_arity< is_sequence< na > > : int_<-1> { }; }
+
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/unwrap.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/mpl/aux_/unwrap.hpp"
+namespace boost { namespace mpl { namespace aux {
+
+template< typename F >
+inline
+F& unwrap(F& f, long)
+{
+    return f;
+}
+
+template< typename F >
+inline
+F&
+unwrap(reference_wrapper<F>& f, int)
+{
+    return f;
+}
+
+template< typename F >
+inline
+F&
+unwrap(reference_wrapper<F> const& f, int)
+{
+    return f;
+}
+
+}}}
+# 26 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/utility/value_init.hpp"
+# 1 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 17 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 2
+
+namespace boost {
+
+namespace detail { namespace aligned_storage {
+
+static const std::size_t alignment_of_max_align = ::boost::alignment_of<max_align>::value
+
+
+     ;
+
+
+
+
+template <
+      std::size_t size_
+    , std::size_t alignment_
+>
+struct aligned_storage_imp
+{
+    union data_t
+    {
+        char buf[size_];
+
+        typename mpl::eval_if_c<
+              alignment_ == std::size_t(-1)
+            , mpl::identity<detail::max_align>
+            , type_with_alignment<alignment_>
+            >::type align_;
+    } data_;
+    void* address() const { return const_cast<aligned_storage_imp*>(this); }
+};
+
+template< std::size_t alignment_ >
+struct aligned_storage_imp<0u,alignment_>
+{
+
+    void* address() const { return 0; }
+};
+
+}}
+
+template <
+      std::size_t size_
+    , std::size_t alignment_ = std::size_t(-1)
+>
+class aligned_storage :
+
+   private
+
+
+
+   detail::aligned_storage::aligned_storage_imp<size_, alignment_>
+{
+
+public:
+
+    typedef detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;
+
+    static const std::size_t size = size_
+
+
+         ;
+    static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ )
+
+
+
+
+
+
+         ;
+
+
+
+
+
+
+private:
+
+    aligned_storage(const aligned_storage&);
+    aligned_storage& operator=(const aligned_storage&);
+# 118 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
+public:
+
+    aligned_storage()
+    {
+    }
+
+    ~aligned_storage()
+    {
+    }
+
+public:
+
+    void* address()
+    {
+        return static_cast<type*>(this)->address();
+    }
+
+
+
+    const void* address() const
+    {
+        return static_cast<const type*>(this)->address();
+    }
+
+
+
+
+
+
+
+};
+# 168 "/usr/include/boost-1_42/boost/aligned_storage.hpp"
+template <std::size_t size_, std::size_t alignment_>
+struct is_pod<boost::detail::aligned_storage::aligned_storage_imp<size_,alignment_> >
+   : ::boost::integral_constant<bool,true>
+{
+   
+};
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 180 "/usr/include/boost-1_42/boost/aligned_storage.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/swap.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/swap.hpp"
+# 1 "/usr/include/boost-1_42/boost/utility/swap.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/utility/swap.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 26 "/usr/include/boost-1_42/boost/utility/swap.hpp" 2
+
+namespace boost_swap_impl
+{
+  template<class T>
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  template<class T1, class T2>
+  void swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+# 11 "/usr/include/boost-1_42/boost/swap.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstring" 2 3
+# 29 "/usr/include/boost-1_42/boost/utility/value_init.hpp" 2
+
+
+namespace boost {
+
+template<class T>
+class value_initialized
+{
+  private :
+    struct wrapper
+    {
+
+      typename
+
+      remove_const<T>::type data;
+    };
+
+    mutable
+
+      typename
+
+      aligned_storage<sizeof(wrapper), alignment_of<wrapper>::value>::type x;
+
+    wrapper * wrapper_address() const
+    {
+      return static_cast<wrapper *>( static_cast<void*>(&x));
+    }
+
+  public :
+
+    value_initialized()
+    {
+      std::memset(&x, 0, sizeof(x));
+# 70 "/usr/include/boost-1_42/boost/utility/value_init.hpp"
+      new (wrapper_address()) wrapper();
+
+
+
+    }
+
+    value_initialized(value_initialized const & arg)
+    {
+      new (wrapper_address()) wrapper( static_cast<wrapper const &>(*(arg.wrapper_address())));
+    }
+
+    value_initialized & operator=(value_initialized const & arg)
+    {
+
+      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((! is_const<T>::value) == 0 ? false : true) >)> boost_static_assert_typedef_84;
+      *wrapper_address() = static_cast<wrapper const &>(*(arg.wrapper_address()));
+      return *this;
+    }
+
+    ~value_initialized()
+    {
+      wrapper_address()->wrapper::~wrapper();
+    }
+
+    T const & data() const
+    {
+      return wrapper_address()->data;
+    }
+
+    T& data()
+    {
+      return wrapper_address()->data;
+    }
+
+    void swap(value_initialized & arg)
+    {
+      ::boost::swap( this->data(), arg.data() );
+    }
+
+    operator T const &() const { return this->data(); }
+
+    operator T&() { return this->data(); }
+
+} ;
+
+
+
+template<class T>
+T const& get ( value_initialized<T> const& x )
+{
+  return x.data() ;
+}
+template<class T>
+T& get ( value_initialized<T>& x )
+{
+  return x.data() ;
+}
+
+template<class T>
+void swap ( value_initialized<T> & lhs, value_initialized<T> & rhs )
+{
+  lhs.swap(rhs) ;
+}
+
+
+class initialized_value_t
+{
+  public :
+
+    template <class T> operator T() const
+    {
+      return get( value_initialized<T>() );
+    }
+};
+
+initialized_value_t const initialized_value = {} ;
+
+
+}
+# 29 "/usr/include/boost-1_42/boost/mpl/for_each.hpp" 2
+
+namespace boost { namespace mpl {
+
+namespace aux {
+
+template< bool done = true >
+struct for_each_impl
+{
+    template<
+          typename Iterator
+        , typename LastIterator
+        , typename TransformFunc
+        , typename F
+        >
+    static void execute(
+          Iterator*
+        , LastIterator*
+        , TransformFunc*
+        , F
+        )
+    {
+    }
+};
+
+template<>
+struct for_each_impl<false>
+{
+    template<
+          typename Iterator
+        , typename LastIterator
+        , typename TransformFunc
+        , typename F
+        >
+    static void execute(
+          Iterator*
+        , LastIterator*
+        , TransformFunc*
+        , F f
+        )
+    {
+        typedef typename deref<Iterator>::type item;
+        typedef typename apply1<TransformFunc,item>::type arg;
+
+
+
+        value_initialized<arg> x;
+        aux::unwrap(f, 0)(boost::get(x));
+
+        typedef typename mpl::next<Iterator>::type iter;
+        for_each_impl<boost::is_same<iter,LastIterator>::value>
+            ::execute( static_cast<iter*>(0), static_cast<LastIterator*>(0), static_cast<TransformFunc*>(0), f);
+    }
+};
+
+}
+
+
+
+template<
+      typename Sequence
+    , typename TransformOp
+    , typename F
+    >
+inline
+void for_each(F f, Sequence* = 0, TransformOp* = 0)
+{
+    enum { mpl_assertion_in_line_95 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) ( is_sequence<Sequence> ))0, 1 ) ) ) };
+
+    typedef typename begin<Sequence>::type first;
+    typedef typename end<Sequence>::type last;
+
+    aux::for_each_impl< boost::is_same<first,last>::value >
+        ::execute(static_cast<first*>(0), static_cast<last*>(0), static_cast<TransformOp*>(0), f);
+}
+
+template<
+      typename Sequence
+    , typename F
+    >
+inline
+void for_each(F f, Sequence* = 0)
+{
+    for_each<Sequence, identity<> >(f);
+}
+
+}}
+# 31 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/single_view.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/single_view.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/single_element_iter.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/mpl/aux_/single_element_iter.hpp"
+namespace boost { namespace mpl {
+
+
+
+namespace aux {
+
+template< typename T, int is_last_ >
+struct sel_iter;
+
+template< typename T >
+struct sel_iter<T,0>
+{
+    typedef random_access_iterator_tag category;
+    typedef sel_iter<T,1> next;
+    typedef T type;
+};
+
+template< typename T >
+struct sel_iter<T,1>
+{
+    typedef random_access_iterator_tag category;
+    typedef sel_iter<T,0> prior;
+};
+
+}
+
+template< typename T, int is_last_, typename Distance >
+struct advance< aux::sel_iter<T,is_last_>,Distance>
+{
+    typedef aux::sel_iter<
+          T
+        , ( is_last_ + Distance::value )
+        > type;
+};
+
+template<
+      typename T
+    , int l1
+    , int l2
+    >
+struct distance< aux::sel_iter<T,l1>, aux::sel_iter<T,l2> >
+    : int_<( l2 - l1 )>
+{
+};
+# 116 "/usr/include/boost-1_42/boost/mpl/aux_/single_element_iter.hpp"
+}}
+# 18 "/usr/include/boost-1_42/boost/mpl/single_view.hpp" 2
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename T = na
+    >
+struct single_view
+    : iterator_range<
+          aux::sel_iter<T,0>
+        , aux::sel_iter<T,1>
+        >
+{
+};
+
+template<> struct single_view< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : single_view< T1 > { }; }; template< typename Tag > struct lambda< single_view< na > , Tag , int_<-1> > { typedef false_ is_le; typedef single_view< na > result_; typedef single_view< na > type; }; namespace aux { template< typename T1 > struct template_arity< single_view< T1 > > : int_<1> { }; template<> struct template_arity< single_view< na > > : int_<-1> { }; }
+
+}}
+# 33 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp" 2
+# 42 "/usr/include/boost-1_42/boost/python/object/class_metadata.hpp"
+namespace boost { namespace python { namespace objects {
+
+
+void copy_class_object(type_info const& src, type_info const& dst);
+
+
+
+
+template <class Derived>
+struct register_base_of
+{
+    template <class Base>
+    inline void operator()(Base*) const
+    {
+
+        enum { mpl_assertion_in_line_57 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_same<Base,Derived>))0, 1 ) ) ) };
+
+
+
+
+
+        register_dynamic_id<Base>();
+
+
+        register_conversion<Derived,Base>(false);
+
+
+        this->register_downcast((Base*)0, is_polymorphic<Base>());
+    }
+
+ private:
+    static inline void register_downcast(void*, mpl::false_) {}
+
+    template <class Base>
+    static inline void register_downcast(Base*, mpl::true_)
+    {
+        register_conversion<Base, Derived>(true);
+    }
+
+};
+
+
+
+
+
+template <class T, class Bases>
+inline void register_shared_ptr_from_python_and_casts(T*, Bases)
+{
+
+    python::detail::force_instantiate(converter::shared_ptr_from_python<T>());
+
+
+
+
+
+    register_dynamic_id<T>();
+    mpl::for_each(register_base_of<T>(), (Bases*)0, (add_pointer<mpl::_>*)0);
+}
+
+
+
+
+template <class T, class Prev>
+struct select_held_type
+  : mpl::if_<
+        mpl::or_<
+            python::detail::specifies_bases<T>
+          , is_same<T,noncopyable>
+        >
+      , Prev
+      , T
+    >
+{
+};
+
+template <
+    class T
+  , class X1
+  , class X2
+  , class X3
+>
+struct class_metadata
+{
+
+
+
+
+
+
+
+    typedef typename select_held_type<
+        X1
+      , typename select_held_type<
+            X2
+          , typename select_held_type<
+                X3
+              , python::detail::not_specified
+            >::type
+        >::type
+    >::type held_type_arg;
+
+
+    typedef typename python::detail::select_bases<
+        X1
+      , typename python::detail::select_bases<
+            X2
+          , typename python::detail::select_bases<
+                X3
+              , python::bases<>
+            >::type
+        >::type
+    >::type bases;
+
+    typedef mpl::or_<
+        is_same<X1,noncopyable>
+      , is_same<X2,noncopyable>
+      , is_same<X3,noncopyable>
+    > is_noncopyable;
+
+
+
+
+
+
+    typedef typename mpl::if_<
+        is_same<held_type_arg,python::detail::not_specified>, T, held_type_arg
+    >::type held_type;
+
+
+    typedef is_convertible<held_type*,T*> use_value_holder;
+
+
+
+    typedef typename mpl::eval_if<
+        use_value_holder
+      , mpl::identity<held_type>
+      , pointee<held_type>
+    >::type wrapped;
+
+
+    typedef mpl::or_<
+        has_back_reference<T>
+      , is_same<held_type_arg,T>
+      , is_base_and_derived<T,wrapped>
+    > use_back_reference;
+
+
+    typedef typename mpl::eval_if<
+        use_back_reference
+      , mpl::if_<
+            use_value_holder
+          , value_holder_back_reference<T, wrapped>
+          , pointer_holder_back_reference<held_type,T>
+        >
+      , mpl::if_<
+            use_value_holder
+          , value_holder<T>
+          , pointer_holder<held_type,wrapped>
+        >
+    >::type holder;
+
+    inline static void register_()
+    {
+        class_metadata::register_aux((T*)0);
+    }
+
+ private:
+    template <class T2>
+    inline static void register_aux(python::wrapper<T2>*)
+    {
+        typedef typename mpl::not_<is_same<T2,wrapped> >::type use_callback;
+        class_metadata::register_aux2((T2*)0, use_callback());
+    }
+
+    inline static void register_aux(void*)
+    {
+        typedef typename is_base_and_derived<T,wrapped>::type use_callback;
+        class_metadata::register_aux2((T*)0, use_callback());
+    }
+
+    template <class T2, class Callback>
+    inline static void register_aux2(T2*, Callback)
+    {
+        objects::register_shared_ptr_from_python_and_casts((T2*)0, bases());
+
+        class_metadata::maybe_register_callback_class((T2*)0, Callback());
+
+        class_metadata::maybe_register_class_to_python((T2*)0, is_noncopyable());
+
+        class_metadata::maybe_register_pointer_to_python(
+            (T2*)0, (use_value_holder*)0, (use_back_reference*)0);
+    }
+
+
+
+
+
+    inline static void maybe_register_pointer_to_python(...) {}
+
+
+    inline static void maybe_register_pointer_to_python(void*,void*,mpl::true_*)
+    {
+        objects::copy_class_object(python::type_id<T>(), python::type_id<back_reference<T const &> >());
+        objects::copy_class_object(python::type_id<T>(), python::type_id<back_reference<T &> >());
+    }
+
+
+    template <class T2>
+    inline static void maybe_register_pointer_to_python(T2*, mpl::false_*, mpl::false_*)
+    {
+        python::detail::force_instantiate(
+            objects::class_value_wrapper<
+                held_type
+              , make_ptr_instance<T2, pointer_holder<held_type, T2> >
+            >()
+        );
+
+
+        objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>());
+
+    }
+
+
+
+    inline static void maybe_register_class_to_python(void*, mpl::true_) {}
+
+
+    template <class T2>
+    inline static void maybe_register_class_to_python(T2*, mpl::false_)
+    {
+        python::detail::force_instantiate(class_cref_wrapper<T2, make_instance<T2, holder> >());
+
+
+        objects::copy_class_object(python::type_id<T2>(), python::type_id<held_type>());
+
+    }
+
+
+
+
+    inline static void maybe_register_callback_class(void*, mpl::false_) {}
+
+    template <class T2>
+    inline static void maybe_register_callback_class(T2*, mpl::true_)
+    {
+        objects::register_shared_ptr_from_python_and_casts(
+            (wrapped*)0, mpl::single_view<T2>());
+
+
+        objects::copy_class_object(python::type_id<T2>(), python::type_id<wrapped>());
+    }
+};
+
+}}}
+# 24 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/pickle_support.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object/pickle_support.hpp"
+namespace boost { namespace python {
+
+namespace api
+{
+  class object;
+}
+using api::object;
+class tuple;
+
+ object const& make_instance_reduce_function();
+
+struct pickle_suite;
+
+namespace error_messages {
+
+  template <class T>
+  struct missing_pickle_suite_function_or_incorrect_signature {};
+
+  inline void must_be_derived_from_pickle_suite(pickle_suite const&) {}
+}
+
+namespace detail { struct pickle_suite_registration; }
+
+struct pickle_suite
+{
+  private:
+    struct inaccessible {};
+    friend struct detail::pickle_suite_registration;
+  public:
+    static inaccessible* getinitargs() { return 0; }
+    static inaccessible* getstate() { return 0; }
+    static inaccessible* setstate() { return 0; }
+    static bool getstate_manages_dict() { return false; }
+};
+
+namespace detail {
+
+  struct pickle_suite_registration
+  {
+    typedef pickle_suite::inaccessible inaccessible;
+
+    template <class Class_, class Tgetinitargs>
+    static
+    void
+    register_(
+      Class_& cl,
+      tuple (*getinitargs_fn)(Tgetinitargs),
+      inaccessible* (* )(),
+      inaccessible* (* )(),
+      bool)
+    {
+      cl.enable_pickling_(false);
+      cl.def("__getinitargs__", getinitargs_fn);
+    }
+
+    template <class Class_,
+              class Rgetstate, class Tgetstate,
+              class Tsetstate, class Ttuple>
+    static
+    void
+    register_(
+      Class_& cl,
+      inaccessible* (* )(),
+      Rgetstate (*getstate_fn)(Tgetstate),
+      void (*setstate_fn)(Tsetstate, Ttuple),
+      bool getstate_manages_dict)
+    {
+      cl.enable_pickling_(getstate_manages_dict);
+      cl.def("__getstate__", getstate_fn);
+      cl.def("__setstate__", setstate_fn);
+    }
+
+    template <class Class_,
+              class Tgetinitargs,
+              class Rgetstate, class Tgetstate,
+              class Tsetstate, class Ttuple>
+    static
+    void
+    register_(
+      Class_& cl,
+      tuple (*getinitargs_fn)(Tgetinitargs),
+      Rgetstate (*getstate_fn)(Tgetstate),
+      void (*setstate_fn)(Tsetstate, Ttuple),
+      bool getstate_manages_dict)
+    {
+      cl.enable_pickling_(getstate_manages_dict);
+      cl.def("__getinitargs__", getinitargs_fn);
+      cl.def("__getstate__", getstate_fn);
+      cl.def("__setstate__", setstate_fn);
+    }
+
+    template <class Class_>
+    static
+    void
+    register_(
+      Class_&,
+      ...)
+    {
+      typedef typename
+        error_messages::missing_pickle_suite_function_or_incorrect_signature<
+          Class_>::error_type error_type;
+    }
+  };
+
+  template <typename PickleSuiteType>
+  struct pickle_suite_finalize
+  : PickleSuiteType,
+    pickle_suite_registration
+  {};
+
+}
+
+}}
+# 25 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/overloads_fwd.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+
+struct overloads_base;
+
+template <class OverloadsT, class NameSpaceT, class SigT>
+inline void define_with_defaults(char const* name, OverloadsT const&, NameSpaceT&, SigT const&);
+
+}}}
+# 28 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/operator_id.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+
+enum operator_id
+{
+    op_add,
+    op_sub,
+    op_mul,
+    op_div,
+    op_mod,
+    op_divmod,
+    op_pow,
+    op_lshift,
+    op_rshift,
+    op_and,
+    op_xor,
+    op_or,
+    op_neg,
+    op_pos,
+    op_abs,
+    op_invert,
+    op_int,
+    op_long,
+    op_float,
+    op_str,
+    op_cmp,
+    op_gt,
+    op_ge,
+    op_lt,
+    op_le,
+    op_eq,
+    op_ne,
+    op_iadd,
+    op_isub,
+    op_imul,
+    op_idiv,
+    op_imod,
+    op_ilshift,
+    op_irshift,
+    op_iand,
+    op_ixor,
+    op_ior,
+    op_complex,
+
+
+
+    op_nonzero,
+
+    op_repr
+};
+
+}}}
+# 29 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/tuple/tuple.hpp" 1
+# 33 "/usr/include/boost-1_42/boost/tuple/tuple.hpp"
+# 1 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp" 1
+# 43 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
+namespace boost {
+namespace tuples {
+
+
+struct null_type {};
+
+
+namespace detail {
+  inline const null_type cnull() { return null_type(); }
+
+
+
+
+
+template <bool If, class Then, class Else> struct IF { typedef Then RET; };
+
+template <class Then, class Else> struct IF<false, Then, Else> {
+  typedef Else RET;
+};
+
+}
+
+
+template <class HT, class TT> struct cons;
+
+
+
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type>
+class tuple;
+
+
+template<class T> struct length;
+
+
+
+namespace detail {
+
+
+
+template<class T>
+class generate_error;
+
+
+
+
+template< int N >
+struct get_class {
+  template<class RET, class HT, class TT >
+  inline static RET get(const cons<HT, TT>& t)
+  {
+
+
+
+
+
+    return get_class<N-1>::template get<RET>(t.tail);
+
+  }
+  template<class RET, class HT, class TT >
+  inline static RET get(cons<HT, TT>& t)
+  {
+
+
+
+    return get_class<N-1>::template get<RET>(t.tail);
+
+  }
+};
+
+template<>
+struct get_class<0> {
+  template<class RET, class HT, class TT>
+  inline static RET get(const cons<HT, TT>& t)
+  {
+    return t.head;
+  }
+  template<class RET, class HT, class TT>
+  inline static RET get(cons<HT, TT>& t)
+  {
+    return t.head;
+  }
+};
+
+}
+# 140 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
+template<int N, class T>
+struct element
+{
+private:
+  typedef typename T::tail_type Next;
+public:
+  typedef typename element<N-1, Next>::type type;
+};
+template<class T>
+struct element<0,T>
+{
+  typedef typename T::head_type type;
+};
+
+template<int N, class T>
+struct element<N, const T>
+{
+private:
+  typedef typename T::tail_type Next;
+  typedef typename element<N-1, Next>::type unqualified_type;
+public:
+
+
+
+  typedef typename boost::add_const<unqualified_type>::type type;
+
+
+};
+template<class T>
+struct element<0,const T>
+{
+
+
+
+  typedef typename boost::add_const<typename T::head_type>::type type;
+
+};
+# 233 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
+template <class T> struct access_traits {
+  typedef const T& const_type;
+  typedef T& non_const_type;
+
+  typedef const typename boost::remove_cv<T>::type& parameter_type;
+
+
+
+
+
+
+};
+
+template <class T> struct access_traits<T&> {
+
+  typedef T& const_type;
+  typedef T& non_const_type;
+
+  typedef T& parameter_type;
+};
+
+
+
+template<int N, class HT, class TT>
+inline typename access_traits<
+                  typename element<N, cons<HT, TT> >::type
+                >::non_const_type
+get(cons<HT, TT>& c ) {
+
+
+
+  return detail::get_class<N>::template
+
+         get<
+           typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::non_const_type,
+           HT,TT
+         >(c);
+}
+
+
+
+
+template<int N, class HT, class TT>
+inline typename access_traits<
+                  typename element<N, cons<HT, TT> >::type
+                >::const_type
+get(const cons<HT, TT>& c ) {
+
+
+
+  return detail::get_class<N>::template
+
+         get<
+           typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::const_type,
+           HT,TT
+         >(c);
+}
+
+
+namespace detail {
+
+
+
+
+
+
+
+template <class T> class non_storeable_type {
+  non_storeable_type();
+};
+
+template <class T> struct wrap_non_storeable_type {
+  typedef typename IF<
+    ::boost::is_function<T>::value, non_storeable_type<T>, T
+  >::RET type;
+};
+template <> struct wrap_non_storeable_type<void> {
+  typedef non_storeable_type<void> type;
+};
+
+}
+
+template <class HT, class TT>
+struct cons {
+
+  typedef HT head_type;
+  typedef TT tail_type;
+
+  typedef typename
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+
+  stored_head_type head;
+  tail_type tail;
+
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  typename access_traits<tail_type>::non_const_type
+  get_tail() { return tail; }
+
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  typename access_traits<tail_type>::const_type
+  get_tail() const { return tail; }
+
+  cons() : head(), tail() {}
+
+
+
+
+
+
+
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const tail_type& t)
+    : head (h), tail(t) {}
+
+  template <class T1, class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (t1),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      {}
+
+  template <class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  cons( const null_type& , T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      {}
+
+
+  template <class HT2, class TT2>
+  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
+
+  template <class HT2, class TT2>
+  cons& operator=( const cons<HT2, TT2>& u ) {
+    head=u.head; tail=u.tail; return *this;
+  }
+
+
+
+  cons& operator=(const cons& u) {
+    head = u.head; tail = u.tail; return *this;
+  }
+
+  template <class T1, class T2>
+  cons& operator=( const std::pair<T1, T2>& u ) {
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((length<cons>::value == 2) == 0 ? false : true) >)> boost_static_assert_typedef_388;
+    head = u.first; tail.head = u.second; return *this;
+  }
+
+
+  template <int N>
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::non_const_type
+  get() {
+    return boost::tuples::get<N>(*this);
+  }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::const_type
+  get() const {
+    return boost::tuples::get<N>(*this);
+  }
+};
+
+template <class HT>
+struct cons<HT, null_type> {
+
+  typedef HT head_type;
+  typedef null_type tail_type;
+  typedef cons<HT, null_type> self_type;
+
+  typedef typename
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+  stored_head_type head;
+
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  null_type get_tail() { return null_type(); }
+
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  const null_type get_tail() const { return null_type(); }
+
+
+  cons() : head() {}
+
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const null_type& = null_type())
+    : head (h) {}
+
+  template<class T1>
+  cons(T1& t1, const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head (t1) {}
+
+  cons(const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head () {}
+
+  template <class HT2>
+  cons( const cons<HT2, null_type>& u ) : head(u.head) {}
+
+  template <class HT2>
+  cons& operator=(const cons<HT2, null_type>& u )
+  { head = u.head; return *this; }
+
+
+
+  cons& operator=(const cons& u) { head = u.head; return *this; }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, self_type>::type
+            >::non_const_type
+  get() {
+    return boost::tuples::get<N>(*this);
+  }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, self_type>::type
+           >::const_type
+  get() const {
+    return boost::tuples::get<N>(*this);
+  }
+
+};
+
+
+
+template<class T>
+struct length {
+  static const int value = 1 + length<typename T::tail_type>::value;
+};
+
+template<>
+struct length<tuple<> > {
+  static const int value = 0;
+};
+
+template<>
+struct length<tuple<> const> {
+  static const int value = 0;
+};
+
+template<>
+struct length<null_type> {
+  static const int value = 0;
+};
+
+template<>
+struct length<null_type const> {
+  static const int value = 0;
+};
+
+namespace detail {
+
+
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+struct map_tuple_to_cons
+{
+  typedef cons<T0,
+               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
+                                          T6, T7, T8, T9, null_type>::type
+              > type;
+};
+
+
+template <>
+struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
+{
+  typedef null_type type;
+};
+
+}
+
+
+
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+
+class tuple :
+  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+{
+public:
+  typedef typename
+    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
+  typedef typename inherited::head_type head_type;
+  typedef typename inherited::tail_type tail_type;
+
+
+
+  tuple() {}
+
+  tuple(typename access_traits<T0>::parameter_type t0)
+    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1)
+    : inherited(t0, t1, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2)
+    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3)
+    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4)
+    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5)
+    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8,
+        typename access_traits<T9>::parameter_type t9)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
+
+
+  template<class U1, class U2>
+  tuple(const cons<U1, U2>& p) : inherited(p) {}
+
+  template <class U1, class U2>
+  tuple& operator=(const cons<U1, U2>& k) {
+    inherited::operator=(k);
+    return *this;
+  }
+
+  template <class U1, class U2>
+  tuple& operator=(const std::pair<U1, U2>& k) {
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((length<tuple>::value == 2) == 0 ? false : true) >)> boost_static_assert_typedef_645;
+    this->head = k.first;
+    this->tail.head = k.second;
+    return *this;
+  }
+
+};
+
+
+template <>
+class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
+  public null_type
+{
+public:
+  typedef null_type inherited;
+};
+
+
+
+namespace detail {
+
+struct swallow_assign {
+
+  template<typename T>
+  swallow_assign const& operator=(const T&) const {
+    return *this;
+  }
+};
+
+}
+
+
+detail::swallow_assign const ignore = detail::swallow_assign();
+# 696 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
+template<class T>
+struct make_tuple_traits {
+  typedef T type;
+
+
+
+
+
+
+
+};
+# 720 "/usr/include/boost-1_42/boost/tuple/detail/tuple_basic.hpp"
+template<class T>
+struct make_tuple_traits<T&> {
+  typedef typename
+     detail::generate_error<T&>::
+       do_not_use_with_reference_type error;
+};
+
+
+
+
+
+template<class T, int n> struct make_tuple_traits <T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n> struct make_tuple_traits<volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+template<class T>
+struct make_tuple_traits<reference_wrapper<T> >{
+  typedef T& type;
+};
+
+template<class T>
+struct make_tuple_traits<const reference_wrapper<T> >{
+  typedef T& type;
+};
+
+
+
+
+namespace detail {
+
+
+
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type
+>
+struct make_tuple_mapper {
+  typedef
+    tuple<typename make_tuple_traits<T0>::type,
+          typename make_tuple_traits<T1>::type,
+          typename make_tuple_traits<T2>::type,
+          typename make_tuple_traits<T3>::type,
+          typename make_tuple_traits<T4>::type,
+          typename make_tuple_traits<T5>::type,
+          typename make_tuple_traits<T6>::type,
+          typename make_tuple_traits<T7>::type,
+          typename make_tuple_traits<T8>::type,
+          typename make_tuple_traits<T9>::type> type;
+};
+
+}
+
+
+inline tuple<> make_tuple() {
+  return tuple<>();
+}
+
+template<class T0>
+inline typename detail::make_tuple_mapper<T0>::type
+make_tuple(const T0& t0) {
+  typedef typename detail::make_tuple_mapper<T0>::type t;
+  return t(t0);
+}
+
+template<class T0, class T1>
+inline typename detail::make_tuple_mapper<T0, T1>::type
+make_tuple(const T0& t0, const T1& t1) {
+  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
+  return t(t0, t1);
+}
+
+template<class T0, class T1, class T2>
+inline typename detail::make_tuple_mapper<T0, T1, T2>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
+  return t(t0, t1, t2);
+}
+
+template<class T0, class T1, class T2, class T3>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
+  return t(t0, t1, t2, t3);
+}
+
+template<class T0, class T1, class T2, class T3, class T4>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
+  return t(t0, t1, t2, t3, t4);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
+  return t(t0, t1, t2, t3, t4, t5);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8>
+inline typename detail::make_tuple_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
+                  const T8& t8) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8, class T9>
+inline typename detail::make_tuple_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
+                  const T8& t8, const T9& t9) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
+}
+
+
+
+
+template<class T1>
+inline tuple<T1&> tie(T1& t1) {
+  return tuple<T1&> (t1);
+}
+
+template<class T1, class T2>
+inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
+  return tuple<T1&, T2&> (t1, t2);
+}
+
+template<class T1, class T2, class T3>
+inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
+  return tuple<T1&, T2&, T3&> (t1, t2, t3);
+}
+
+template<class T1, class T2, class T3, class T4>
+inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
+  return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
+}
+
+template<class T1, class T2, class T3, class T4, class T5>
+inline tuple<T1&, T2&, T3&, T4&, T5&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
+  return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+         class T8>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
+           (t1, t2, t3, t4, t5, t6, t7, t8);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+         class T8, class T9>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
+           T9& t9) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
+            (t1, t2, t3, t4, t5, t6, t7, t8, t9);
+}
+
+template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
+         class T8, class T9, class T10>
+inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
+tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
+           T9& t9, T10& t10) {
+  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
+           (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
+}
+
+}
+}
+# 34 "/usr/include/boost-1_42/boost/tuple/tuple.hpp" 2
+
+
+
+namespace boost {
+
+using tuples::tuple;
+using tuples::make_tuple;
+using tuples::tie;
+
+using tuples::get;
+# 87 "/usr/include/boost-1_42/boost/tuple/tuple.hpp"
+}
+# 19 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp" 2
+
+
+
+namespace boost { namespace python {
+
+struct default_call_policies;
+
+namespace detail
+{
+
+
+
+
+  template <class Tuple, class Predicate>
+  struct tuple_extract;
+
+
+
+  template <bool matched>
+  struct tuple_extract_impl
+  {
+      template <class Tuple, class Predicate>
+      struct apply
+      {
+          typedef typename Tuple::head_type result_type;
+
+          static typename Tuple::head_type extract(Tuple const& x)
+          {
+              return x.get_head();
+          }
+      };
+  };
+
+
+
+  template <>
+  struct tuple_extract_impl<false>
+  {
+      template <class Tuple, class Predicate>
+      struct apply
+      {
+
+          typedef tuple_extract<typename Tuple::tail_type, Predicate> next;
+          typedef typename next::result_type result_type;
+
+          static result_type extract(Tuple const& x)
+          {
+              return next::extract(x.get_tail());
+          }
+      };
+  };
+
+
+
+  template <class Tuple, class Predicate>
+  struct tuple_extract_base_select
+  {
+      typedef typename Tuple::head_type head_type;
+      typedef typename mpl::apply1<Predicate, typename add_reference<head_type>::type>::type match_t;
+      static const bool match = match_t::value;
+      typedef typename tuple_extract_impl<match>::template apply<Tuple,Predicate> type;
+  };
+
+  template <class Tuple, class Predicate>
+  struct tuple_extract
+      : tuple_extract_base_select<
+         Tuple
+         , typename mpl::lambda<Predicate>::type
+      >::type
+  {
+  };
+
+
+
+
+
+
+
+  template <class Tuple>
+  struct doc_extract
+      : tuple_extract<
+        Tuple
+        , mpl::not_<
+           mpl::or_<
+               indirect_traits::is_reference_to_class<mpl::_1>
+             , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
+           >
+        >
+     >
+  {
+  };
+
+  template <class Tuple>
+  struct keyword_extract
+      : tuple_extract<Tuple, is_reference_to_keywords<mpl::_1 > >
+  {
+  };
+
+  template <class Tuple>
+  struct policy_extract
+      : tuple_extract<
+          Tuple
+          , mpl::and_<
+             mpl::not_<is_same<not_specified const&,mpl::_1> >
+              , indirect_traits::is_reference_to_class<mpl::_1 >
+              , mpl::not_<is_reference_to_keywords<mpl::_1 > >
+          >
+        >
+  {
+  };
+
+  template <class Tuple>
+  struct default_implementation_extract
+      : tuple_extract<
+          Tuple
+          , indirect_traits::is_reference_to_member_function_pointer<mpl::_1 >
+          >
+  {
+  };
+# 146 "/usr/include/boost-1_42/boost/python/detail/def_helper.hpp"
+  template <class T1, class T2, class T3, class T4>
+  struct def_helper
+  {
+
+
+
+      typedef boost::tuples::tuple<
+          T1 const&
+          , T2 const&
+          , T3 const&
+          , T4 const&
+          , default_call_policies
+          , detail::keywords<0>
+          , char const*
+          , void(not_specified::*)()
+
+          > all_t;
+
+
+
+      def_helper(T1 const& a1) : m_all(a1,m_nil,m_nil,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2) : m_all(a1,a2,m_nil,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2, T3 const& a3) : m_all(a1,a2,a3,m_nil) {}
+      def_helper(T1 const& a1, T2 const& a2, T3 const& a3, T4 const& a4) : m_all(a1,a2,a3,a4) {}
+
+   private:
+      typedef typename default_implementation_extract<all_t>::result_type default_implementation_t;
+
+   public:
+
+
+
+      static const bool has_default_implementation = ( !is_same<default_implementation_t, void(not_specified::*)()>::value)
+
+                                                                                   ;
+
+   public:
+
+      char const* doc() const
+      {
+          return doc_extract<all_t>::extract(m_all);
+      }
+
+      typename keyword_extract<all_t>::result_type keywords() const
+      {
+          return keyword_extract<all_t>::extract(m_all);
+      }
+
+      typename policy_extract<all_t>::result_type policies() const
+      {
+          return policy_extract<all_t>::extract(m_all);
+      }
+
+      default_implementation_t default_implementation() const
+      {
+          return default_implementation_extract<all_t>::extract(m_all);
+      }
+
+   private:
+      all_t m_all;
+      not_specified m_nil;
+  };
+}
+
+}}
+# 30 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/unwrap_type_id.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/detail/unwrap_type_id.hpp"
+namespace boost { namespace python {
+
+template <class T> class wrapper;
+
+namespace detail {
+
+template <class T>
+inline type_info unwrap_type_id(T*, ...)
+{
+    return type_id<T>();
+}
+
+template <class U, class T>
+inline type_info unwrap_type_id(U*, wrapper<T>*)
+{
+    return type_id<T>();
+}
+
+}}}
+# 32 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/unwrap_wrapper.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/is_wrapper.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/detail/is_wrapper.hpp"
+namespace boost { namespace python {
+
+template <class T> class wrapper;
+
+namespace detail
+{
+  typedef char (&is_not_wrapper)[2];
+  is_not_wrapper is_wrapper_helper(...);
+  template <class T>
+  char is_wrapper_helper(wrapper<T> const volatile*);
+
+
+  template <class T>
+  struct is_wrapper
+    : mpl::bool_<(sizeof(detail::is_wrapper_helper((T*)0)) == 1)>
+  {};
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/detail/unwrap_wrapper.hpp" 2
+
+
+
+namespace boost { namespace python { namespace detail {
+
+template <class T>
+struct unwrap_wrapper_helper
+{
+    typedef typename T::_wrapper_wrapped_type_ type;
+};
+
+template <class T>
+struct unwrap_wrapper_
+  : mpl::eval_if<is_wrapper<T>,unwrap_wrapper_helper<T>,mpl::identity<T> >
+{};
+
+template <class T>
+typename unwrap_wrapper_<T>::type*
+unwrap_wrapper(T*)
+{
+    return 0;
+}
+
+}}}
+# 33 "/usr/include/boost-1_42/boost/python/class.hpp" 2
+# 60 "/usr/include/boost-1_42/boost/python/class.hpp"
+namespace boost { namespace python {
+
+template <class DerivedVisitor> class def_visitor;
+
+enum no_init_t { no_init };
+
+namespace detail
+{
+
+
+
+  struct write_type_id
+  {
+      write_type_id(type_info**p) : p(p) {}
+
+
+      template <class T>
+      void operator()(T*) const
+      {
+          *(*p)++ = type_id<T>();
+      }
+
+      type_info** p;
+  };
+
+  template <class T>
+  struct is_data_member_pointer
+      : mpl::and_<
+            is_member_pointer<T>
+          , mpl::not_<is_member_function_pointer<T> >
+        >
+  {};
+# 107 "/usr/include/boost-1_42/boost/python/class.hpp"
+  namespace error
+  {
+# 118 "/usr/include/boost-1_42/boost/python/class.hpp"
+    template <class C> struct assertion_failed { };
+    template <class C> struct assertion_ok { typedef C failed; };
+
+    template <class C>
+    struct assertion
+        : mpl::if_<C, assertion_ok<C>, assertion_failed<C> >::type
+    {};
+
+
+
+
+
+
+    template <class Default>
+    void not_a_derived_class_member(Default) {}
+
+    template <class T, class Fn>
+    struct virtual_function_default
+    {
+        template <class Default>
+        static void
+        must_be_derived_class_member(Default const&)
+        {
+            typedef typename assertion<mpl::not_<is_same<Default,Fn> > >::failed test0;
+
+            typedef typename assertion<is_polymorphic<T> >::failed test1;
+
+            typedef typename assertion<is_member_function_pointer<Fn> >::failed test2;
+            not_a_derived_class_member<Default>(Fn());
+        }
+    };
+  }
+}
+
+
+
+template <
+    class W
+    , class X1
+    , class X2
+    , class X3
+    >
+class class_ : public objects::class_base
+{
+ public:
+    typedef objects::class_base base;
+    typedef class_<W,X1,X2,X3> self;
+    typedef typename objects::class_metadata<W,X1,X2,X3> metadata;
+    typedef W wrapped_type;
+
+ private:
+
+
+
+    struct id_vector
+    {
+        typedef typename metadata::bases bases;
+
+        id_vector()
+        {
+
+            ids[0] = detail::unwrap_type_id((W*)0, (W*)0);
+
+
+            type_info* p = ids + 1;
+            mpl::for_each(detail::write_type_id(&p), (bases*)0, (add_pointer<mpl::_>*)0);
+        }
+
+        static const std::size_t size = mpl::size<bases>::value + 1
+                                                            ;
+        type_info ids[size];
+    };
+    friend struct id_vector;
+
+ public:
+
+
+    class_(char const* name, char const* doc = 0);
+
+
+    class_(char const* name, no_init_t);
+
+
+    class_(char const* name, char const* doc, no_init_t);
+
+
+    template <class DerivedT>
+    inline class_(char const* name, init_base<DerivedT> const& i)
+        : base(name, id_vector::size, id_vector().ids)
+    {
+        this->initialize(i);
+    }
+
+
+    template <class DerivedT>
+    inline class_(char const* name, char const* doc, init_base<DerivedT> const& i)
+        : base(name, id_vector::size, id_vector().ids, doc)
+    {
+        this->initialize(i);
+    }
+
+ public:
+
+
+    template <class Derived>
+    self& def(def_visitor<Derived> const& visitor)
+    {
+        visitor.visit(*this);
+        return *this;
+    }
+
+
+
+
+    template <class F>
+    self& def(char const* name, F f)
+    {
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, f, detail::def_helper<char const*>(0), &f);
+        return *this;
+    }
+
+    template <class A1, class A2>
+    self& def(char const* name, A1 a1, A2 const& a2)
+    {
+        this->def_maybe_overloads(name, a1, a2, &a2);
+        return *this;
+    }
+
+    template <class Fn, class A1, class A2>
+    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2)
+    {
+
+
+
+
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, fn
+          , detail::def_helper<A1,A2>(a1,a2)
+          , &fn);
+
+        return *this;
+    }
+
+    template <class Fn, class A1, class A2, class A3>
+    self& def(char const* name, Fn fn, A1 const& a1, A2 const& a2, A3 const& a3)
+    {
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name, fn
+          , detail::def_helper<A1,A2,A3>(a1,a2,a3)
+          , &fn);
+
+        return *this;
+    }
+
+
+
+
+    template <class D>
+    self& def_readonly(char const* name, D const& d, char const* doc=0)
+    {
+        return this->def_readonly_impl(name, d, doc );
+    }
+
+    template <class D>
+    self& def_readwrite(char const* name, D const& d, char const* doc=0)
+    {
+        return this->def_readwrite_impl(name, d, doc );
+    }
+
+    template <class D>
+    self& def_readonly(char const* name, D& d, char const* doc=0)
+    {
+        return this->def_readonly_impl(name, d, doc );
+    }
+
+    template <class D>
+    self& def_readwrite(char const* name, D& d, char const* doc=0)
+    {
+        return this->def_readwrite_impl(name, d, doc );
+    }
+
+
+
+    template <class Get>
+    self& add_property(char const* name, Get fget, char const* docstr = 0)
+    {
+        base::add_property(name, this->make_getter(fget), docstr);
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_property(char const* name, Get fget, Set fset, char const* docstr = 0)
+    {
+        base::add_property(
+            name, this->make_getter(fget), this->make_setter(fset), docstr);
+        return *this;
+    }
+# 361 "/usr/include/boost-1_42/boost/python/class.hpp"
+    template <class Get>
+    self& add_static_property(char const* name, Get fget)
+    {
+        base::add_static_property(name, object(fget));
+        return *this;
+    }
+
+    template <class Get, class Set>
+    self& add_static_property(char const* name, Get fget, Set fset)
+    {
+        base::add_static_property(name, object(fget), object(fset));
+        return *this;
+    }
+
+    template <class U>
+    self& setattr(char const* name, U const& x)
+    {
+        this->base::setattr(name, object(x));
+        return *this;
+    }
+
+
+    template <typename PickleSuiteType>
+    self& def_pickle(PickleSuiteType const& x)
+    {
+      error_messages::must_be_derived_from_pickle_suite(x);
+      detail::pickle_suite_finalize<PickleSuiteType>::register_(
+        *this,
+        &PickleSuiteType::getinitargs,
+        &PickleSuiteType::getstate,
+        &PickleSuiteType::setstate,
+        PickleSuiteType::getstate_manages_dict());
+      return *this;
+    }
+
+    self& enable_pickling()
+    {
+        this->base::enable_pickling_(false);
+        return *this;
+    }
+
+    self& staticmethod(char const* name)
+    {
+        this->make_method_static(name);
+        return *this;
+    }
+ private:
+# 416 "/usr/include/boost-1_42/boost/python/class.hpp"
+    template <class F>
+    object make_getter(F f)
+    {
+        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
+
+        return this->make_fn_impl(
+            detail::unwrap_wrapper((W*)0)
+          , f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>()
+        );
+    }
+
+    template <class F>
+    object make_setter(F f)
+    {
+        typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
+
+        return this->make_fn_impl(
+            detail::unwrap_wrapper((W*)0)
+          , f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>()
+        );
+    }
+
+    template <class T, class F>
+    object make_fn_impl(T*, F const& f, mpl::false_, void*, mpl::false_)
+    {
+        return python::make_function(f, default_call_policies(), detail::get_signature(f, (T*)0));
+    }
+
+    template <class T, class D, class B>
+    object make_fn_impl(T*, D B::*pm_, mpl::false_, char*, mpl::true_)
+    {
+        D T::*pm = pm_;
+        return python::make_getter(pm);
+    }
+
+    template <class T, class D, class B>
+    object make_fn_impl(T*, D B::*pm_, mpl::false_, int*, mpl::true_)
+    {
+        D T::*pm = pm_;
+        return python::make_setter(pm);
+    }
+
+    template <class T, class F>
+    object make_fn_impl(T*, F const& x, mpl::true_, void*, mpl::false_)
+    {
+        return x;
+    }
+
+
+    template <class D, class B>
+    self& def_readonly_impl(
+        char const* name, D B::*pm_, char const* doc )
+    {
+        return this->add_property(name, pm_, doc);
+    }
+
+    template <class D, class B>
+    self& def_readwrite_impl(
+        char const* name, D B::*pm_, char const* doc )
+    {
+        return this->add_property(name, pm_, pm_, doc);
+    }
+
+    template <class D>
+    self& def_readonly_impl(
+        char const* name, D& d, char const* )
+    {
+        return this->add_static_property(name, python::make_getter(d));
+    }
+
+    template <class D>
+    self& def_readwrite_impl(
+        char const* name, D& d, char const* )
+    {
+        return this->add_static_property(name, python::make_getter(d), python::make_setter(d));
+    }
+
+    template <class DefVisitor>
+    inline void initialize(DefVisitor const& i)
+    {
+        metadata::register_();
+
+        typedef typename metadata::holder holder;
+        this->set_instance_size( objects::additional_instance_size<holder>::value );
+
+        this->def(i);
+    }
+
+    inline void initialize(no_init_t)
+    {
+        metadata::register_();
+        this->def_no_init();
+    }
+
+
+
+
+
+
+    template <class T, class Helper, class LeafVisitor, class Visitor>
+    inline void def_impl(
+        T*
+      , char const* name
+      , LeafVisitor
+      , Helper const& helper
+      , def_visitor<Visitor> const* v
+    )
+    {
+        v->visit(*this, name, helper);
+    }
+
+    template <class T, class Fn, class Helper>
+    inline void def_impl(
+        T*
+      , char const* name
+      , Fn fn
+      , Helper const& helper
+      , ...
+    )
+    {
+        objects::add_to_namespace(
+            *this
+          , name
+          , make_function(
+                fn
+              , helper.policies()
+              , helper.keywords()
+              , detail::get_signature(fn, (T*)0)
+            )
+          , helper.doc()
+        );
+
+        this->def_default(name, fn, helper, mpl::bool_<Helper::has_default_implementation>());
+    }
+# 558 "/usr/include/boost-1_42/boost/python/class.hpp"
+    template <class Fn, class Helper>
+    inline void def_default(
+        char const* name
+        , Fn
+        , Helper const& helper
+        , mpl::bool_<true>)
+    {
+        detail::error::virtual_function_default<W,Fn>::must_be_derived_class_member(
+            helper.default_implementation());
+
+        objects::add_to_namespace(
+            *this, name,
+            make_function(
+                helper.default_implementation(), helper.policies(), helper.keywords())
+            );
+    }
+
+    template <class Fn, class Helper>
+    inline void def_default(char const*, Fn, Helper const&, mpl::bool_<false>)
+    { }
+# 587 "/usr/include/boost-1_42/boost/python/class.hpp"
+    template <class OverloadsT, class SigT>
+    void def_maybe_overloads(
+        char const* name
+        , SigT sig
+        , OverloadsT const& overloads
+        , detail::overloads_base const*)
+
+    {
+
+
+        detail::define_with_defaults(
+            name, overloads, *this, detail::get_signature(sig));
+    }
+
+    template <class Fn, class A1>
+    void def_maybe_overloads(
+        char const* name
+        , Fn fn
+        , A1 const& a1
+        , ...)
+    {
+        this->def_impl(
+            detail::unwrap_wrapper((W*)0)
+          , name
+          , fn
+          , detail::def_helper<A1>(a1)
+          , &fn
+        );
+
+    }
+
+};
+
+
+
+
+
+
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->initialize(init<>());
+
+}
+
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, no_init_t)
+    : base(name, id_vector::size, id_vector().ids)
+{
+    this->initialize(no_init);
+}
+
+template <class W, class X1, class X2, class X3>
+inline class_<W,X1,X2,X3>::class_(char const* name, char const* doc, no_init_t)
+    : base(name, id_vector::size, id_vector().ids, doc)
+{
+    this->initialize(no_init);
+}
+
+}}
+# 19 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/copy_const_reference.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/copy_const_reference.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class R>
+  struct copy_const_reference_expects_a_const_reference_return_type
+
+  {}
+
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::if_c<
+            indirect_traits::is_reference_to_const<T>::value
+          , to_python_value<T>
+          , detail::copy_const_reference_expects_a_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}}
+# 20 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/copy_non_const_reference.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/copy_non_const_reference.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class R>
+  struct copy_non_const_reference_expects_a_non_const_reference_return_type
+
+  {}
+
+  ;
+}
+
+template <class T> struct to_python_value;
+
+struct copy_non_const_reference
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::if_c<
+            indirect_traits::is_reference_to_non_const<T>::value
+            , to_python_value<T>
+            , detail::copy_non_const_reference_expects_a_non_const_reference_return_type<T>
+        >::type type;
+    };
+};
+
+
+}}
+# 21 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/def.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/scope.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/scope.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+  extern PyObject* current_scope;
+}
+
+class scope
+  : public object
+{
+ public:
+    inline scope(scope const&);
+    inline scope(object const&);
+    inline scope();
+    inline ~scope();
+
+ private:
+    PyObject* m_previous_scope;
+
+ private:
+    void operator=(scope const&);
+};
+
+inline scope::scope(object const& new_scope)
+    : object(new_scope)
+    , m_previous_scope(detail::current_scope)
+{
+    detail::current_scope = python::incref(new_scope.ptr());
+}
+
+inline scope::scope()
+    : object(detail::borrowed_reference(
+                 detail::current_scope ? detail::current_scope : (&_Py_NoneStruct)
+                 ))
+    , m_previous_scope(python::xincref(detail::current_scope))
+{
+}
+
+inline scope::~scope()
+{
+    python::xdecref(detail::current_scope);
+    detail::current_scope = m_previous_scope;
+}
+
+namespace converter
+{
+  template <>
+  struct object_manager_traits<scope>
+      : object_manager_traits<object>
+  {
+  };
+}
+
+
+inline scope::scope(scope const& new_scope)
+    : object(new_scope)
+    , m_previous_scope(detail::current_scope)
+{
+    detail::current_scope = python::incref(new_scope.ptr());
+}
+
+}}
+# 15 "/usr/include/boost-1_42/boost/python/def.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/signature.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/def.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/detail/scope.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/detail/scope.hpp"
+namespace boost { namespace python { namespace detail {
+
+void scope_setattr_doc(char const* name, object const& obj, char const* doc);
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/def.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  namespace error
+  {
+
+    template <bool> struct multiple_functions_passed_to_def;
+    template <> struct multiple_functions_passed_to_def<false> { typedef char type; };
+  }
+
+
+
+
+
+  template <class F, class Helper>
+  void def_from_helper(
+      char const* name, F const& fn, Helper const& helper)
+  {
+
+      typedef typename error::multiple_functions_passed_to_def<
+          Helper::has_default_implementation
+          >::type assertion;
+
+      detail::scope_setattr_doc(
+          name, boost::python::make_function(
+              fn
+              , helper.policies()
+              , helper.keywords())
+          , helper.doc()
+          );
+  }
+
+
+
+
+
+
+
+  template <class Fn, class A1>
+  void
+  def_maybe_overloads(
+      char const* name
+      , Fn fn
+      , A1 const& a1
+      , ...)
+  {
+      detail::def_from_helper(name, fn, def_helper<A1>(a1));
+  }
+
+  template <class StubsT, class SigT>
+  void def_maybe_overloads(
+      char const* name
+      , SigT sig
+      , StubsT const& stubs
+      , detail::overloads_base const*)
+  {
+      scope current;
+
+      detail::define_with_defaults(
+          name, stubs, current, detail::get_signature(sig));
+  }
+
+  template <class T>
+  object make_function1(T fn, ...) { return make_function(fn); }
+
+  inline
+  object make_function1(object const& x, object const*) { return x; }
+}
+
+template <class Fn>
+void def(char const* name, Fn fn)
+{
+    detail::scope_setattr_doc(name, detail::make_function1(fn, &fn), 0);
+}
+
+template <class Arg1T, class Arg2T>
+void def(char const* name, Arg1T arg1, Arg2T const& arg2)
+{
+    detail::def_maybe_overloads(name, arg1, arg2, &arg2);
+}
+
+template <class F, class A1, class A2>
+void def(char const* name, F f, A1 const& a1, A2 const& a2)
+{
+    detail::def_from_helper(name, f, detail::def_helper<A1,A2>(a1,a2));
+}
+
+template <class F, class A1, class A2, class A3>
+void def(char const* name, F f, A1 const& a1, A2 const& a2, A3 const& a3)
+{
+    detail::def_from_helper(name, f, detail::def_helper<A1,A2,A3>(a1,a2,a3));
+}
+
+}}
+# 23 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/dict.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/dict.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/list.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/list.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/pytype_object_mgr_traits.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/converter/pytype_object_mgr_traits.hpp"
+namespace boost { namespace python { namespace converter {
+
+
+
+template <class T> struct object_manager_traits;
+
+
+
+
+template <PyTypeObject* pytype, class T>
+struct pytype_object_manager_traits
+    : pyobject_type<T, pytype>
+{
+    static const bool is_specialized = true;
+    static inline python::detail::new_reference adopt(PyObject*);
+};
+
+
+
+
+template <PyTypeObject* pytype, class T>
+inline python::detail::new_reference pytype_object_manager_traits<pytype,T>::adopt(PyObject* x)
+{
+    return python::detail::new_reference(python::pytype_check(pytype, x));
+}
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/list.hpp" 2
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  struct list_base : object
+  {
+      void append(object_cref);
+
+      ssize_t count(object_cref value) const;
+
+      void extend(object_cref sequence);
+
+      long index(object_cref value) const;
+
+      void insert(ssize_t index, object_cref);
+      void insert(object const& index, object_cref);
+
+      object pop();
+      object pop(ssize_t index);
+      object pop(object const& index);
+
+      void remove(object_cref value);
+
+      void reverse();
+
+      void sort();
+
+
+
+
+      void sort(object_cref cmpfunc);
+
+
+   protected:
+      list_base();
+      explicit list_base(object_cref sequence);
+
+      inline explicit list_base(python::detail::borrowed_reference p) : object(p) {} inline explicit list_base(python::detail::new_reference p) : object(p) {} inline explicit list_base(python::detail::new_non_null_reference p) : object(p) {}
+   private:
+      static detail::new_non_null_reference call(object const&);
+  };
+}
+
+class list : public detail::list_base
+{
+    typedef detail::list_base base;
+ public:
+    list() {}
+
+    template <class T>
+    explicit list(T const& sequence)
+        : base(object(sequence))
+    {
+    }
+
+    template <class T>
+    void append(T const& x)
+    {
+        base::append(object(x));
+    }
+
+    template <class T>
+    long count(T const& value) const
+    {
+        return base::count(object(value));
+    }
+
+    template <class T>
+    void extend(T const& x)
+    {
+        base::extend(object(x));
+    }
+
+    template <class T>
+    long index(T const& x) const
+    {
+        return base::index(object(x));
+    }
+
+    template <class T>
+    void insert(ssize_t index, T const& x)
+    {
+        base::insert(index, object(x));
+    }
+
+    template <class T>
+    void insert(object const& index, T const& x)
+    {
+        base::insert(index, object(x));
+    }
+
+    object pop() { return base::pop(); }
+    object pop(ssize_t index) { return base::pop(index); }
+
+    template <class T>
+    object pop(T const& index)
+    {
+        return base::pop(object(index));
+    }
+
+    template <class T>
+    void remove(T const& value)
+    {
+        base::remove(object(value));
+    }
+
+
+    void sort() { base::sort(); }
+
+    template <class T>
+    void sort(T const& value)
+    {
+        base::sort(object(value));
+    }
+
+
+ public:
+    inline explicit list(python::detail::borrowed_reference p) : base(p) {} inline explicit list(python::detail::new_reference p) : base(p) {} inline explicit list(python::detail::new_non_null_reference p) : base(p) {}
+};
+
+
+
+
+namespace converter
+{
+  template <>
+  struct object_manager_traits<list>
+      : pytype_object_manager_traits<&PyList_Type,list>
+  {
+  };
+}
+
+}}
+# 12 "/usr/include/boost-1_42/boost/python/dict.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/tuple.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/tuple.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  struct tuple_base : object
+  {
+   protected:
+      tuple_base();
+      tuple_base(object_cref sequence);
+
+      inline explicit tuple_base(python::detail::borrowed_reference p) : object(p) {} inline explicit tuple_base(python::detail::new_reference p) : object(p) {} inline explicit tuple_base(python::detail::new_non_null_reference p) : object(p) {}
+
+   private:
+      static detail::new_reference call(object const&);
+  };
+}
+
+class tuple : public detail::tuple_base
+{
+    typedef detail::tuple_base base;
+ public:
+    tuple() {}
+
+    template <class T>
+    explicit tuple(T const& sequence)
+        : base(object(sequence))
+    {
+    }
+
+ public:
+    inline explicit tuple(python::detail::borrowed_reference p) : base(p) {} inline explicit tuple(python::detail::new_reference p) : base(p) {} inline explicit tuple(python::detail::new_non_null_reference p) : base(p) {}
+};
+
+
+
+
+
+namespace converter
+{
+  template <>
+  struct object_manager_traits<tuple>
+      : pytype_object_manager_traits<&PyTuple_Type,tuple>
+  {
+  };
+}
+
+
+inline tuple make_tuple() { return tuple(); }
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 52 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0>
+    tuple
+    make_tuple( A0 const& a0)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(1));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr()));
+        return result;
+    }
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(2));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr()));
+        return result;
+    }
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(3));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr()));
+        return result;
+    }
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(4));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr()));
+        return result;
+    }
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(5));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr()));
+        return result;
+    }
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(6));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr()));
+        return result;
+    }
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(7));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr()));
+        return result;
+    }
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(8));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr()));
+        return result;
+    }
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(9));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr()));
+        return result;
+    }
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(10));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr()));
+        return result;
+    }
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(11));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr()));
+        return result;
+    }
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(12));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr()));
+        return result;
+    }
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(13));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[12] = python::incref(python::object(a12).ptr()));
+        return result;
+    }
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(14));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[12] = python::incref(python::object(a12).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[13] = python::incref(python::object(a13).ptr()));
+        return result;
+    }
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/detail/make_tuple.hpp"
+    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+    tuple
+    make_tuple( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12 , A13 const& a13 , A14 const& a14)
+    {
+        tuple result((detail::new_reference)::PyTuple_New(15));
+        (((PyTupleObject *)(result.ptr()))->ob_item[0] = python::incref(python::object(a0).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[1] = python::incref(python::object(a1).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[2] = python::incref(python::object(a2).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[3] = python::incref(python::object(a3).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[4] = python::incref(python::object(a4).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[5] = python::incref(python::object(a5).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[6] = python::incref(python::object(a6).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[7] = python::incref(python::object(a7).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[8] = python::incref(python::object(a8).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[9] = python::incref(python::object(a9).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[10] = python::incref(python::object(a10).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[11] = python::incref(python::object(a11).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[12] = python::incref(python::object(a12).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[13] = python::incref(python::object(a13).ptr())); (((PyTupleObject *)(result.ptr()))->ob_item[14] = python::incref(python::object(a14).ptr()));
+        return result;
+    }
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 66 "/usr/include/boost-1_42/boost/python/tuple.hpp" 2
+
+}}
+# 13 "/usr/include/boost-1_42/boost/python/dict.hpp" 2
+
+
+namespace boost { namespace python {
+
+class dict;
+
+namespace detail
+{
+  struct dict_base : object
+  {
+
+      void clear();
+
+
+      dict copy();
+
+
+      object get(object_cref k) const;
+
+      object get(object_cref k, object_cref d) const;
+
+
+      bool has_key(object_cref k) const;
+
+
+      list items() const;
+
+
+      object iteritems() const;
+
+
+      object iterkeys() const;
+
+
+      object itervalues() const;
+
+
+      list keys() const;
+
+
+
+      tuple popitem();
+
+
+      object setdefault(object_cref k);
+
+      object setdefault(object_cref k, object_cref d);
+
+
+      void update(object_cref E);
+
+
+      list values() const;
+
+   protected:
+
+
+
+
+      dict_base();
+      explicit dict_base(object_cref data);
+
+      inline explicit dict_base(python::detail::borrowed_reference p) : object(p) {} inline explicit dict_base(python::detail::new_reference p) : object(p) {} inline explicit dict_base(python::detail::new_non_null_reference p) : object(p) {}
+   private:
+      static detail::new_reference call(object const&);
+  };
+}
+
+class dict : public detail::dict_base
+{
+    typedef detail::dict_base base;
+ public:
+
+
+
+
+    dict() {}
+
+    template <class T>
+    explicit dict(T const& data)
+        : base(object(data))
+    {
+    }
+
+    template<class T>
+    object get(T const& k) const
+    {
+        return base::get(object(k));
+    }
+
+    template<class T1, class T2>
+    object get(T1 const& k, T2 const& d) const
+    {
+        return base::get(object(k),object(d));
+    }
+
+    template<class T>
+    bool has_key(T const& k) const
+    {
+        return base::has_key(object(k));
+    }
+
+    template<class T>
+    object setdefault(T const& k)
+    {
+        return base::setdefault(object(k));
+    }
+
+    template<class T1, class T2>
+    object setdefault(T1 const& k, T2 const& d)
+    {
+        return base::setdefault(object(k),object(d));
+    }
+
+    template<class T>
+    void update(T const& E)
+    {
+        base::update(object(E));
+    }
+
+ public:
+    inline explicit dict(python::detail::borrowed_reference p) : base(p) {} inline explicit dict(python::detail::new_reference p) : base(p) {} inline explicit dict(python::detail::new_non_null_reference p) : base(p) {}
+};
+
+
+
+
+namespace converter
+{
+  template <>
+  struct object_manager_traits<dict>
+      : pytype_object_manager_traits<&PyDict_Type,dict>
+  {
+  };
+}
+
+}}
+# 25 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/docstring_options.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/object/function.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/object/function.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/function2.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/function/function2.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/function/function2.hpp" 2
+# 12 "/usr/include/boost-1_42/boost/python/object/function.hpp" 2
+
+
+
+namespace boost { namespace python { namespace objects {
+
+
+struct function : PyObject
+{
+    function(
+        py_function const&
+        , python::detail::keyword const* names_and_defaults
+        , unsigned num_keywords);
+
+    ~function();
+
+    PyObject* call(PyObject*, PyObject*) const;
+
+
+
+
+    static void add_to_namespace(
+        object const& name_space, char const* name, object const& attribute);
+
+    static void add_to_namespace(
+        object const& name_space, char const* name, object const& attribute, char const* doc);
+
+    object const& doc() const;
+    void doc(object const& x);
+
+    object const& name() const;
+
+ private:
+    object signature(bool show_return_type=false) const;
+    object signatures(bool show_return_type=false) const;
+    void argument_error(PyObject* args, PyObject* keywords) const;
+    void add_overload(handle<function> const&);
+
+ private:
+    py_function m_fn;
+    handle<function> m_overloads;
+    object m_name;
+    object m_namespace;
+    object m_doc;
+    object m_arg_names;
+    unsigned m_nkeyword_values;
+    friend class function_doc_signature_generator;
+};
+
+
+
+
+inline object const& function::doc() const
+{
+    return this->m_doc;
+}
+
+inline void function::doc(object const& x)
+{
+    this->m_doc = x;
+}
+
+inline object const& function::name() const
+{
+    return this->m_name;
+}
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/docstring_options.hpp" 2
+
+namespace boost { namespace python {
+
+
+
+class docstring_options : boost::noncopyable
+{
+  public:
+      docstring_options(bool show_all=true)
+      {
+          previous_show_user_defined_ = show_user_defined_;
+          previous_show_py_signatures_ = show_py_signatures_;
+          previous_show_cpp_signatures_ = show_cpp_signatures_;
+          show_user_defined_ = show_all;
+          show_cpp_signatures_ = show_all;
+          show_py_signatures_ = show_all;
+      }
+
+      docstring_options(bool show_user_defined, bool show_signatures)
+      {
+          previous_show_user_defined_ = show_user_defined_;
+          previous_show_cpp_signatures_ = show_cpp_signatures_;
+          previous_show_py_signatures_ = show_py_signatures_;
+          show_user_defined_ = show_user_defined;
+          show_cpp_signatures_ = show_signatures;
+          show_py_signatures_ = show_signatures;
+      }
+
+      docstring_options(bool show_user_defined, bool show_py_signatures, bool show_cpp_signatures)
+      {
+          previous_show_user_defined_ = show_user_defined_;
+          previous_show_cpp_signatures_ = show_cpp_signatures_;
+          previous_show_py_signatures_ = show_py_signatures_;
+          show_user_defined_ = show_user_defined;
+          show_cpp_signatures_ = show_cpp_signatures;
+          show_py_signatures_ = show_py_signatures;
+      }
+
+      ~docstring_options()
+      {
+          show_user_defined_ = previous_show_user_defined_;
+          show_cpp_signatures_ = previous_show_cpp_signatures_;
+          show_py_signatures_ = previous_show_py_signatures_;
+      }
+
+      void
+      disable_user_defined() { show_user_defined_ = false; }
+
+      void
+      enable_user_defined() { show_user_defined_ = true; }
+
+      void
+      disable_py_signatures()
+      {
+        show_py_signatures_ = false;
+      }
+
+      void
+      enable_py_signatures()
+      {
+        show_py_signatures_ = true;
+      }
+
+      void
+      disable_cpp_signatures()
+      {
+        show_cpp_signatures_ = false;
+      }
+
+      void
+      enable_cpp_signatures()
+      {
+        show_cpp_signatures_ = true;
+      }
+
+      void
+      disable_signatures()
+      {
+        show_cpp_signatures_ = false;
+        show_py_signatures_ = false;
+      }
+
+      void
+      enable_signatures()
+      {
+        show_cpp_signatures_ = true;
+        show_py_signatures_ = true;
+      }
+
+      void
+      disable_all()
+      {
+        show_user_defined_ = false;
+        show_cpp_signatures_ = false;
+        show_py_signatures_ = false;
+      }
+
+      void
+      enable_all()
+      {
+        show_user_defined_ = true;
+        show_cpp_signatures_ = true;
+        show_py_signatures_ = true;
+      }
+
+      friend struct objects::function;
+
+  private:
+      static volatile bool show_user_defined_;
+      static volatile bool show_cpp_signatures_;
+      static volatile bool show_py_signatures_;
+      bool previous_show_user_defined_;
+      bool previous_show_cpp_signatures_;
+      bool previous_show_py_signatures_;
+};
+
+}}
+# 26 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/enum.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/enum.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/enum_base.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/object/enum_base.hpp"
+namespace boost { namespace python { namespace objects {
+
+struct enum_base : python::api::object
+{
+ protected:
+    enum_base(
+        char const* name
+        , converter::to_python_function_t
+        , converter::convertible_function
+        , converter::constructor_function
+        , type_info
+        , const char *doc = 0
+        );
+
+    void add_value(char const* name, long value);
+    void export_values();
+
+    static PyObject* to_python(PyTypeObject* type, long x);
+};
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/enum.hpp" 2
+
+
+
+namespace boost { namespace python {
+
+template <class T>
+struct enum_ : public objects::enum_base
+{
+    typedef objects::enum_base base;
+
+
+    enum_(char const* name, char const* doc = 0);
+
+
+    inline enum_<T>& value(char const* name, T);
+
+
+
+    inline enum_<T>& export_values();
+ private:
+    static PyObject* to_python(void const* x);
+    static void* convertible_from_python(PyObject* obj);
+    static void construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data);
+};
+
+template <class T>
+inline enum_<T>::enum_(char const* name, char const* doc )
+    : base(
+        name
+        , &enum_<T>::to_python
+        , &enum_<T>::convertible_from_python
+        , &enum_<T>::construct
+        , type_id<T>()
+        , doc
+        )
+{
+}
+
+
+
+template <class T>
+PyObject* enum_<T>::to_python(void const* x)
+{
+    return base::to_python(
+        converter::registered<T>::converters.m_class_object
+        , static_cast<long>(*(T const*)x));
+}
+# 66 "/usr/include/boost-1_42/boost/python/enum.hpp"
+template <class T>
+void* enum_<T>::convertible_from_python(PyObject* obj)
+{
+    return PyObject_IsInstance(
+        obj
+        , upcast<PyObject>(
+            converter::registered<T>::converters.m_class_object))
+
+        ? obj : 0;
+}
+
+
+
+template <class T>
+void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data)
+{
+
+
+
+    T x = static_cast<T>((((PyIntObject *)(obj))->ob_ival));
+
+    void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes;
+    new (storage) T(x);
+    data->convertible = storage;
+}
+
+template <class T>
+inline enum_<T>& enum_<T>::value(char const* name, T x)
+{
+    this->add_value(name, static_cast<long>(x));
+    return *this;
+}
+
+template <class T>
+inline enum_<T>& enum_<T>::export_values()
+{
+    this->base::export_values();
+    return *this;
+}
+
+}}
+# 27 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/exception_translator.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/exception_translator.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/bind.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind/bind.hpp" 1
+# 28 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+# 1 "/usr/include/boost-1_42/boost/is_placeholder.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/is_placeholder.hpp"
+namespace boost
+{
+
+template< class T > struct is_placeholder
+{
+    enum _vt { value = 0 };
+};
+
+}
+# 29 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/bind/arg.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/bind/arg.hpp"
+namespace boost
+{
+
+template< int I > struct arg
+{
+    arg()
+    {
+    }
+
+    template< class T > arg( T const & )
+    {
+
+        typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
+    }
+};
+
+template< int I > bool operator==( arg<I> const &, arg<I> const & )
+{
+    return true;
+}
+
+
+
+template< int I > struct is_placeholder< arg<I> >
+{
+    enum _vt { value = I };
+};
+
+template< int I > struct is_placeholder< arg<I> (*) () >
+{
+    enum _vt { value = I };
+};
+
+
+
+}
+# 30 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/visit_each.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/visit_each.hpp"
+namespace boost {
+  template<typename Visitor, typename T>
+  inline void visit_each(Visitor& visitor, const T& t, long)
+  {
+    visitor(t);
+  }
+
+  template<typename Visitor, typename T>
+  inline void visit_each(Visitor& visitor, const T& t)
+  {
+    visit_each(visitor, t, 0);
+  }
+}
+# 32 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+# 41 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind/storage.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/bind/storage.hpp"
+namespace boost
+{
+
+namespace _bi
+{
+
+
+
+template<class A1> struct storage1
+{
+    explicit storage1( A1 a1 ): a1_( a1 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        visit_each(v, a1_, 0);
+    }
+
+    A1 a1_;
+};
+
+
+
+template<int I> struct storage1< boost::arg<I> >
+{
+    explicit storage1( boost::arg<I> ) {}
+
+    template<class V> void accept(V &) const { }
+
+    static boost::arg<I> a1_() { return boost::arg<I>(); }
+};
+
+template<int I> struct storage1< boost::arg<I> (*) () >
+{
+    explicit storage1( boost::arg<I> (*) () ) {}
+
+    template<class V> void accept(V &) const { }
+
+    static boost::arg<I> a1_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2> struct storage2: public storage1<A1>
+{
+    typedef storage1<A1> inherited;
+
+    storage2( A1 a1, A2 a2 ): storage1<A1>( a1 ), a2_( a2 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a2_, 0);
+    }
+
+    A2 a2_;
+};
+
+
+
+template<class A1, int I> struct storage2< A1, boost::arg<I> >: public storage1<A1>
+{
+    typedef storage1<A1> inherited;
+
+    storage2( A1 a1, boost::arg<I> ): storage1<A1>( a1 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a2_() { return boost::arg<I>(); }
+};
+
+template<class A1, int I> struct storage2< A1, boost::arg<I> (*) () >: public storage1<A1>
+{
+    typedef storage1<A1> inherited;
+
+    storage2( A1 a1, boost::arg<I> (*) () ): storage1<A1>( a1 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a2_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3> struct storage3: public storage2< A1, A2 >
+{
+    typedef storage2<A1, A2> inherited;
+
+    storage3( A1 a1, A2 a2, A3 a3 ): storage2<A1, A2>( a1, a2 ), a3_( a3 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a3_, 0);
+    }
+
+    A3 a3_;
+};
+
+
+
+template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> >: public storage2< A1, A2 >
+{
+    typedef storage2<A1, A2> inherited;
+
+    storage3( A1 a1, A2 a2, boost::arg<I> ): storage2<A1, A2>( a1, a2 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a3_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, int I> struct storage3< A1, A2, boost::arg<I> (*) () >: public storage2< A1, A2 >
+{
+    typedef storage2<A1, A2> inherited;
+
+    storage3( A1 a1, A2 a2, boost::arg<I> (*) () ): storage2<A1, A2>( a1, a2 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a3_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4> struct storage4: public storage3< A1, A2, A3 >
+{
+    typedef storage3<A1, A2, A3> inherited;
+
+    storage4( A1 a1, A2 a2, A3 a3, A4 a4 ): storage3<A1, A2, A3>( a1, a2, a3 ), a4_( a4 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a4_, 0);
+    }
+
+    A4 a4_;
+};
+
+
+
+template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> >: public storage3< A1, A2, A3 >
+{
+    typedef storage3<A1, A2, A3> inherited;
+
+    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a4_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, int I> struct storage4< A1, A2, A3, boost::arg<I> (*) () >: public storage3< A1, A2, A3 >
+{
+    typedef storage3<A1, A2, A3> inherited;
+
+    storage4( A1 a1, A2 a2, A3 a3, boost::arg<I> (*) () ): storage3<A1, A2, A3>( a1, a2, a3 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a4_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5> struct storage5: public storage4< A1, A2, A3, A4 >
+{
+    typedef storage4<A1, A2, A3, A4> inherited;
+
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ), a5_( a5 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a5_, 0);
+    }
+
+    A5 a5_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> >: public storage4< A1, A2, A3, A4 >
+{
+    typedef storage4<A1, A2, A3, A4> inherited;
+
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a5_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, int I> struct storage5< A1, A2, A3, A4, boost::arg<I> (*) () >: public storage4< A1, A2, A3, A4 >
+{
+    typedef storage4<A1, A2, A3, A4> inherited;
+
+    storage5( A1 a1, A2 a2, A3 a3, A4 a4, boost::arg<I> (*) () ): storage4<A1, A2, A3, A4>( a1, a2, a3, a4 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a5_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6> struct storage6: public storage5< A1, A2, A3, A4, A5 >
+{
+    typedef storage5<A1, A2, A3, A4, A5> inherited;
+
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ), a6_( a6 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a6_, 0);
+    }
+
+    A6 a6_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> >: public storage5< A1, A2, A3, A4, A5 >
+{
+    typedef storage5<A1, A2, A3, A4, A5> inherited;
+
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a6_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, int I> struct storage6< A1, A2, A3, A4, A5, boost::arg<I> (*) () >: public storage5< A1, A2, A3, A4, A5 >
+{
+    typedef storage5<A1, A2, A3, A4, A5> inherited;
+
+    storage6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, boost::arg<I> (*) () ): storage5<A1, A2, A3, A4, A5>( a1, a2, a3, a4, a5 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a6_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct storage7: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
+
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ), a7_( a7 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a7_, 0);
+    }
+
+    A7 a7_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> >: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
+
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a7_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, int I> struct storage7< A1, A2, A3, A4, A5, A6, boost::arg<I> (*) () >: public storage6< A1, A2, A3, A4, A5, A6 >
+{
+    typedef storage6<A1, A2, A3, A4, A5, A6> inherited;
+
+    storage7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, boost::arg<I> (*) () ): storage6<A1, A2, A3, A4, A5, A6>( a1, a2, a3, a4, a5, a6 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a7_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct storage8: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
+
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ), a8_( a8 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a8_, 0);
+    }
+
+    A8 a8_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
+
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a8_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, int I> struct storage8< A1, A2, A3, A4, A5, A6, A7, boost::arg<I> (*) () >: public storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+    typedef storage7<A1, A2, A3, A4, A5, A6, A7> inherited;
+
+    storage8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, boost::arg<I> (*) () ): storage7<A1, A2, A3, A4, A5, A6, A7>( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a8_() { return boost::arg<I>(); }
+};
+
+
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct storage9: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
+
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ), a9_( a9 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+        visit_each(v, a9_, 0);
+    }
+
+    A9 a9_;
+};
+
+
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
+
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a9_() { return boost::arg<I>(); }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, int I> struct storage9< A1, A2, A3, A4, A5, A6, A7, A8, boost::arg<I> (*) () >: public storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+    typedef storage8<A1, A2, A3, A4, A5, A6, A7, A8> inherited;
+
+    storage9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, boost::arg<I> (*) () ): storage8<A1, A2, A3, A4, A5, A6, A7, A8>( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    template<class V> void accept(V & v) const
+    {
+        inherited::accept(v);
+    }
+
+    static boost::arg<I> a9_() { return boost::arg<I>(); }
+};
+
+
+
+}
+
+}
+# 42 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+
+
+
+
+
+
+namespace boost
+{
+
+template<class T> class weak_ptr;
+
+namespace _bi
+{
+
+
+
+template<class R, class F> struct result_traits
+{
+    typedef R type;
+};
+
+
+
+struct unspecified {};
+
+template<class F> struct result_traits<unspecified, F>
+{
+    typedef typename F::result_type type;
+};
+
+template<class F> struct result_traits< unspecified, reference_wrapper<F> >
+{
+    typedef typename F::result_type type;
+};
+
+
+
+
+
+template<class T> bool ref_compare( T const & a, T const & b, long )
+{
+    return a == b;
+}
+
+template<int I> bool ref_compare( arg<I> const &, arg<I> const &, int )
+{
+    return true;
+}
+
+template<int I> bool ref_compare( arg<I> (*) (), arg<I> (*) (), int )
+{
+    return true;
+}
+
+template<class T> bool ref_compare( reference_wrapper<T> const & a, reference_wrapper<T> const & b, int )
+{
+    return a.get_pointer() == b.get_pointer();
+}
+
+
+
+template<class R, class F, class L> class bind_t;
+
+template<class R, class F, class L> bool ref_compare( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b, int )
+{
+    return a.compare( b );
+}
+
+
+
+template<class T> class value
+{
+public:
+
+    value(T const & t): t_(t) {}
+
+    T & get() { return t_; }
+    T const & get() const { return t_; }
+
+    bool operator==(value const & rhs) const
+    {
+        return t_ == rhs.t_;
+    }
+
+private:
+
+    T t_;
+};
+
+
+
+template<class T> bool ref_compare( value< weak_ptr<T> > const & a, value< weak_ptr<T> > const & b, int )
+{
+    return !(a.get() < b.get()) && !(b.get() < a.get());
+}
+
+
+
+template<class T> class type {};
+
+
+
+template<class F> struct unwrapper
+{
+    static inline F & unwrap( F & f, long )
+    {
+        return f;
+    }
+
+    template<class F2> static inline F2 & unwrap( reference_wrapper<F2> rf, int )
+    {
+        return rf.get();
+    }
+
+    template<class R, class T> static inline _mfi::dm<R, T> unwrap( R T::* pm, int )
+    {
+        return _mfi::dm<R, T>( pm );
+    }
+};
+
+
+
+class list0
+{
+public:
+
+    list0() {}
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A &, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)();
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A &, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)();
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A &, int)
+    {
+        unwrapper<F>::unwrap(f, 0)();
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A &, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)();
+    }
+
+    template<class V> void accept(V &) const
+    {
+    }
+
+    bool operator==(list0 const &) const
+    {
+        return true;
+    }
+};
+# 217 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template< class A1 > class list1: private storage1< A1 >
+{
+private:
+
+    typedef storage1< A1 > base_type;
+
+public:
+
+    explicit list1( A1 a1 ): base_type( a1 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+
+    template<class T> T & operator[] ( _bi::value<T> & v ) const { return v.get(); }
+
+    template<class T> T const & operator[] ( _bi::value<T> const & v ) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list1 const & rhs) const
+    {
+        return ref_compare(base_type::a1_, rhs.a1_, 0);
+    }
+};
+
+struct logical_and;
+struct logical_or;
+
+template< class A1, class A2 > class list2: private storage2< A1, A2 >
+{
+private:
+
+    typedef storage2< A1, A2 > base_type;
+
+public:
+
+    list2( A1 a1, A2 a2 ): base_type( a1, a2 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
+    }
+
+    template<class A> bool operator()( type<bool>, logical_and & , A & a, int )
+    {
+        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
+    }
+
+    template<class A> bool operator()( type<bool>, logical_and const & , A & a, int ) const
+    {
+        return a[ base_type::a1_ ] && a[ base_type::a2_ ];
+    }
+
+    template<class A> bool operator()( type<bool>, logical_or & , A & a, int )
+    {
+        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
+    }
+
+    template<class A> bool operator()( type<bool>, logical_or const & , A & a, int ) const
+    {
+        return a[ base_type::a1_ ] || a[ base_type::a2_ ];
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list2 const & rhs) const
+    {
+        return ref_compare(base_type::a1_, rhs.a1_, 0) && ref_compare(base_type::a2_, rhs.a2_, 0);
+    }
+};
+
+template< class A1, class A2, class A3 > class list3: private storage3< A1, A2, A3 >
+{
+private:
+
+    typedef storage3< A1, A2, A3 > base_type;
+
+public:
+
+    list3( A1 a1, A2 a2, A3 a3 ): base_type( a1, a2, a3 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list3 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 );
+    }
+};
+
+template< class A1, class A2, class A3, class A4 > class list4: private storage4< A1, A2, A3, A4 >
+{
+private:
+
+    typedef storage4< A1, A2, A3, A4 > base_type;
+
+public:
+
+    list4( A1 a1, A2 a2, A3 a3, A4 a4 ): base_type( a1, a2, a3, a4 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list4 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5 > class list5: private storage5< A1, A2, A3, A4, A5 >
+{
+private:
+
+    typedef storage5< A1, A2, A3, A4, A5 > base_type;
+
+public:
+
+    list5( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5 ): base_type( a1, a2, a3, a4, a5 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list5 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 );
+    }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6> class list6: private storage6< A1, A2, A3, A4, A5, A6 >
+{
+private:
+
+    typedef storage6< A1, A2, A3, A4, A5, A6 > base_type;
+
+public:
+
+    list6( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6 ): base_type( a1, a2, a3, a4, a5, a6 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list6 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 );
+    }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> class list7: private storage7< A1, A2, A3, A4, A5, A6, A7 >
+{
+private:
+
+    typedef storage7< A1, A2, A3, A4, A5, A6, A7 > base_type;
+
+public:
+
+    list7( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7 ): base_type( a1, a2, a3, a4, a5, a6, a7 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list7 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 );
+    }
+};
+
+template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class list8: private storage8< A1, A2, A3, A4, A5, A6, A7, A8 >
+{
+private:
+
+    typedef storage8< A1, A2, A3, A4, A5, A6, A7, A8 > base_type;
+
+public:
+
+    list8( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list8 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 );
+    }
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> class list9: private storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 >
+{
+private:
+
+    typedef storage9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > base_type;
+
+public:
+
+    list9( A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9 ): base_type( a1, a2, a3, a4, a5, a6, a7, a8, a9 ) {}
+
+    A1 operator[] (boost::arg<1>) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2>) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3>) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4>) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5>) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6>) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7>) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8>) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9>) const { return base_type::a9_; }
+
+    A1 operator[] (boost::arg<1> (*) ()) const { return base_type::a1_; }
+    A2 operator[] (boost::arg<2> (*) ()) const { return base_type::a2_; }
+    A3 operator[] (boost::arg<3> (*) ()) const { return base_type::a3_; }
+    A4 operator[] (boost::arg<4> (*) ()) const { return base_type::a4_; }
+    A5 operator[] (boost::arg<5> (*) ()) const { return base_type::a5_; }
+    A6 operator[] (boost::arg<6> (*) ()) const { return base_type::a6_; }
+    A7 operator[] (boost::arg<7> (*) ()) const { return base_type::a7_; }
+    A8 operator[] (boost::arg<8> (*) ()) const { return base_type::a8_; }
+    A9 operator[] (boost::arg<9> (*) ()) const { return base_type::a9_; }
+
+    template<class T> T & operator[] (_bi::value<T> & v) const { return v.get(); }
+
+    template<class T> T const & operator[] (_bi::value<T> const & v) const { return v.get(); }
+
+    template<class T> T & operator[] (reference_wrapper<T> const & v) const { return v.get(); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> & b) const { return b.eval(*this); }
+
+    template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
+
+    template<class R, class F, class A> R operator()(type<R>, F & f, A & a, long)
+    {
+        return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class R, class F, class A> R operator()(type<R>, F const & f, A & a, long) const
+    {
+        return unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F & f, A & a, int)
+    {
+        unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class F, class A> void operator()(type<void>, F const & f, A & a, int) const
+    {
+        unwrapper<F const>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_], a[base_type::a3_], a[base_type::a4_], a[base_type::a5_], a[base_type::a6_], a[base_type::a7_], a[base_type::a8_], a[base_type::a9_]);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+        base_type::accept(v);
+    }
+
+    bool operator==(list9 const & rhs) const
+    {
+        return
+
+            ref_compare( base_type::a1_, rhs.a1_, 0 ) &&
+            ref_compare( base_type::a2_, rhs.a2_, 0 ) &&
+            ref_compare( base_type::a3_, rhs.a3_, 0 ) &&
+            ref_compare( base_type::a4_, rhs.a4_, 0 ) &&
+            ref_compare( base_type::a5_, rhs.a5_, 0 ) &&
+            ref_compare( base_type::a6_, rhs.a6_, 0 ) &&
+            ref_compare( base_type::a7_, rhs.a7_, 0 ) &&
+            ref_compare( base_type::a8_, rhs.a8_, 0 ) &&
+            ref_compare( base_type::a9_, rhs.a9_, 0 );
+    }
+};
+# 864 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template<class R, class F, class L> class bind_t
+{
+public:
+
+    typedef bind_t this_type;
+
+    bind_t(F f, L const & l): f_(f), l_(l) {}
+
+
+# 1 "/usr/include/boost-1_42/boost/bind/bind_template.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/bind/bind_template.hpp"
+    typedef typename result_traits<R, F>::type result_type;
+
+    result_type operator()()
+    {
+        list0 a;
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    result_type operator()() const
+    {
+        list0 a;
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1> result_type operator()(A1 & a1)
+    {
+        list1<A1 &> a(a1);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1> result_type operator()(A1 & a1) const
+    {
+        list1<A1 &> a(a1);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1> result_type operator()(A1 const & a1)
+    {
+        list1<A1 const &> a(a1);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1> result_type operator()(A1 const & a1) const
+    {
+        list1<A1 const &> a(a1);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
+    {
+        list2<A1 &, A2 &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
+    {
+        list2<A1 &, A2 &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
+    {
+        list2<A1 const &, A2 &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
+    {
+        list2<A1 const &, A2 &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
+    {
+        list2<A1 &, A2 const &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
+    {
+        list2<A1 &, A2 const &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
+    {
+        list2<A1 const &, A2 const &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
+    {
+        list2<A1 const &, A2 const &> a(a1, a2);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
+    {
+        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
+    {
+        list3<A1 &, A2 &, A3 &> a(a1, a2, a3);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
+    {
+        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
+    {
+        list3<A1 const &, A2 const &, A3 const &> a(a1, a2, a3);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
+    {
+        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
+    {
+        list4<A1 &, A2 &, A3 &, A4 &> a(a1, a2, a3, a4);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
+    {
+        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
+    {
+        list4<A1 const &, A2 const &, A3 const &, A4 const &> a(a1, a2, a3, a4);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
+    {
+        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
+    {
+        list5<A1 &, A2 &, A3 &, A4 &, A5 &> a(a1, a2, a3, a4, a5);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
+    {
+        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
+    {
+        list5<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &> a(a1, a2, a3, a4, a5);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
+    {
+        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
+    {
+        list6<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &> a(a1, a2, a3, a4, a5, a6);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
+    {
+        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
+    {
+        list6<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &> a(a1, a2, a3, a4, a5, a6);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
+    {
+        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
+    {
+        list7<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &> a(a1, a2, a3, a4, a5, a6, a7);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
+    {
+        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
+    {
+        list7<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &> a(a1, a2, a3, a4, a5, a6, a7);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
+    {
+        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
+    {
+        list8<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &> a(a1, a2, a3, a4, a5, a6, a7, a8);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
+    {
+        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
+    {
+        list8<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &> a(a1, a2, a3, a4, a5, a6, a7, a8);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
+    {
+        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
+    {
+        list9<A1 &, A2 &, A3 &, A4 &, A5 &, A6 &, A7 &, A8 &, A9 &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
+    {
+        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
+    {
+        list9<A1 const &, A2 const &, A3 const &, A4 const &, A5 const &, A6 const &, A7 const &, A8 const &, A9 const &> a(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+
+
+    template<class A> result_type eval(A & a)
+    {
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class A> result_type eval(A & a) const
+    {
+        return l_(type<result_type>(), f_, a, 0);
+    }
+
+    template<class V> void accept(V & v) const
+    {
+
+
+        using boost::visit_each;
+
+
+        visit_each(v, f_, 0);
+        l_.accept(v);
+    }
+
+    bool compare(this_type const & rhs) const
+    {
+        return ref_compare(f_, rhs.f_, 0) && l_ == rhs.l_;
+    }
+
+private:
+
+    F f_;
+    L l_;
+# 874 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+
+
+};
+# 940 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template<class R, class F, class L> bool function_equal( bind_t<R, F, L> const & a, bind_t<R, F, L> const & b )
+{
+    return a.compare(b);
+}
+# 994 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template< class T, int I > struct add_value_2
+{
+    typedef boost::arg<I> type;
+};
+
+template< class T > struct add_value_2< T, 0 >
+{
+    typedef _bi::value< T > type;
+};
+
+template<class T> struct add_value
+{
+    typedef typename add_value_2< T, boost::is_placeholder< T >::value >::type type;
+};
+
+
+
+template<class T> struct add_value< value<T> >
+{
+    typedef _bi::value<T> type;
+};
+
+template<class T> struct add_value< reference_wrapper<T> >
+{
+    typedef reference_wrapper<T> type;
+};
+
+template<int I> struct add_value< arg<I> >
+{
+    typedef boost::arg<I> type;
+};
+
+template<int I> struct add_value< arg<I> (*) () >
+{
+    typedef boost::arg<I> (*type) ();
+};
+
+template<class R, class F, class L> struct add_value< bind_t<R, F, L> >
+{
+    typedef bind_t<R, F, L> type;
+};
+# 1077 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template<class A1> struct list_av_1
+{
+    typedef typename add_value<A1>::type B1;
+    typedef list1<B1> type;
+};
+
+template<class A1, class A2> struct list_av_2
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef list2<B1, B2> type;
+};
+
+template<class A1, class A2, class A3> struct list_av_3
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef list3<B1, B2, B3> type;
+};
+
+template<class A1, class A2, class A3, class A4> struct list_av_4
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef list4<B1, B2, B3, B4> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5> struct list_av_5
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef list5<B1, B2, B3, B4, B5> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6> struct list_av_6
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef list6<B1, B2, B3, B4, B5, B6> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct list_av_7
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef typename add_value<A7>::type B7;
+    typedef list7<B1, B2, B3, B4, B5, B6, B7> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct list_av_8
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef typename add_value<A7>::type B7;
+    typedef typename add_value<A8>::type B8;
+    typedef list8<B1, B2, B3, B4, B5, B6, B7, B8> type;
+};
+
+template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct list_av_9
+{
+    typedef typename add_value<A1>::type B1;
+    typedef typename add_value<A2>::type B2;
+    typedef typename add_value<A3>::type B3;
+    typedef typename add_value<A4>::type B4;
+    typedef typename add_value<A5>::type B5;
+    typedef typename add_value<A6>::type B6;
+    typedef typename add_value<A7>::type B7;
+    typedef typename add_value<A8>::type B8;
+    typedef typename add_value<A9>::type B9;
+    typedef list9<B1, B2, B3, B4, B5, B6, B7, B8, B9> type;
+};
+
+
+
+struct logical_not
+{
+    template<class V> bool operator()(V const & v) const { return !v; }
+};
+
+template<class R, class F, class L>
+    bind_t< bool, logical_not, list1< bind_t<R, F, L> > >
+    operator! (bind_t<R, F, L> const & f)
+{
+    typedef list1< bind_t<R, F, L> > list_type;
+    return bind_t<bool, logical_not, list_type> ( logical_not(), list_type(f) );
+}
+# 1200 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+struct equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v == w; } }; template<class R, class F, class L, class A2> bind_t< bool, equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator == (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, equal, list_type> ( equal(), list_type(f, a2) ); }
+struct not_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v != w; } }; template<class R, class F, class L, class A2> bind_t< bool, not_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator != (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, not_equal, list_type> ( not_equal(), list_type(f, a2) ); }
+
+struct less { template<class V, class W> bool operator()(V const & v, W const & w) const { return v < w; } }; template<class R, class F, class L, class A2> bind_t< bool, less, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator < (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less, list_type> ( less(), list_type(f, a2) ); }
+struct less_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v <= w; } }; template<class R, class F, class L, class A2> bind_t< bool, less_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator <= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, less_equal, list_type> ( less_equal(), list_type(f, a2) ); }
+
+struct greater { template<class V, class W> bool operator()(V const & v, W const & w) const { return v > w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator > (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater, list_type> ( greater(), list_type(f, a2) ); }
+struct greater_equal { template<class V, class W> bool operator()(V const & v, W const & w) const { return v >= w; } }; template<class R, class F, class L, class A2> bind_t< bool, greater_equal, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator >= (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, greater_equal, list_type> ( greater_equal(), list_type(f, a2) ); }
+
+struct logical_and { template<class V, class W> bool operator()(V const & v, W const & w) const { return v && w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_and, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator && (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_and, list_type> ( logical_and(), list_type(f, a2) ); }
+struct logical_or { template<class V, class W> bool operator()(V const & v, W const & w) const { return v || w; } }; template<class R, class F, class L, class A2> bind_t< bool, logical_or, list2< bind_t<R, F, L>, typename add_value<A2>::type > > operator || (bind_t<R, F, L> const & f, A2 a2) { typedef typename add_value<A2>::type B2; typedef list2< bind_t<R, F, L>, B2> list_type; return bind_t<bool, logical_or, list_type> ( logical_or(), list_type(f, a2) ); }
+# 1240 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template<class V, class T> void visit_each( V & v, value<T> const & t, int )
+{
+    using boost::visit_each;
+    visit_each( v, t.get(), 0 );
+}
+
+template<class V, class R, class F, class L> void visit_each( V & v, bind_t<R, F, L> const & t, int )
+{
+    t.accept( v );
+}
+
+
+
+}
+# 1274 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template< class T > struct is_bind_expression
+{
+    enum _vt { value = 0 };
+};
+
+
+
+template< class R, class F, class L > struct is_bind_expression< _bi::bind_t< R, F, L > >
+{
+    enum _vt { value = 1 };
+};
+# 1296 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+template<class R, class F>
+    _bi::bind_t<R, F, _bi::list0>
+    bind(F f)
+{
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class F, class A1>
+    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
+    bind(F f, A1 a1)
+{
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class F, class A1, class A2>
+    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
+    bind(F f, A1 a1, A2 a2)
+{
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R, class F, class A1, class A2, class A3>
+    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3)
+{
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+
+
+template<class R, class F>
+    _bi::bind_t<R, F, _bi::list0>
+    bind(boost::type<R>, F f)
+{
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class F, class A1>
+    _bi::bind_t<R, F, typename _bi::list_av_1<A1>::type>
+    bind(boost::type<R>, F f, A1 a1)
+{
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class F, class A1, class A2>
+    _bi::bind_t<R, F, typename _bi::list_av_2<A1, A2>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2)
+{
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R, class F, class A1, class A2, class A3>
+    _bi::bind_t<R, F, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3)
+{
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(boost::type<R>, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+
+
+
+
+template<class F>
+    _bi::bind_t<_bi::unspecified, F, _bi::list0>
+    bind(F f)
+{
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type());
+}
+
+template<class F, class A1>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_1<A1>::type>
+    bind(F f, A1 a1)
+{
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1));
+}
+
+template<class F, class A1, class A2>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_2<A1, A2>::type>
+    bind(F f, A1 a1, A2 a2)
+{
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class F, class A1, class A2, class A3>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3)
+{
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class F, class A1, class A2, class A3, class A4>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<_bi::unspecified, F, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<_bi::unspecified, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 1549 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind/bind_cc.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/bind/bind_cc.hpp"
+template<class R>
+    _bi::bind_t<R, R ( *) (), _bi::list0>
+    bind( R ( *f) ())
+{
+    typedef R ( *F) ();
+    typedef _bi::list0 list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type());
+}
+
+template<class R, class B1, class A1>
+    _bi::bind_t<R, R ( *) (B1), typename _bi::list_av_1<A1>::type>
+    bind( R ( *f) (B1), A1 a1)
+{
+    typedef R ( *F) (B1);
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1));
+}
+
+template<class R, class B1, class B2, class A1, class A2>
+    _bi::bind_t<R, R ( *) (B1, B2), typename _bi::list_av_2<A1, A2>::type>
+    bind( R ( *f) (B1, B2), A1 a1, A2 a2)
+{
+    typedef R ( *F) (B1, B2);
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type> (f, list_type(a1, a2));
+}
+
+template<class R,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, R ( *) (B1, B2, B3), typename _bi::list_av_3<A1, A2, A3>::type>
+    bind( R ( *f) (B1, B2, B3), A1 a1, A2 a2, A3 a3)
+{
+    typedef R ( *F) (B1, B2, B3);
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4), typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind( R ( *f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef R ( *F) (B1, B2, B3, B4);
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5), typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5);
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6), typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6);
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7), typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7);
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8), typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8);
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8, class B9,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, R ( *) (B1, B2, B3, B4, B5, B6, B7, B8, B9), typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind( R ( *f) (B1, B2, B3, B4, B5, B6, B7, B8, B9), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef R ( *F) (B1, B2, B3, B4, B5, B6, B7, B8, B9);
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 1550 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+# 1595 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind/bind_mf_cc.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/bind/bind_mf_cc.hpp"
+template<class R, class T,
+    class A1>
+    _bi::bind_t<R, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(R ( T::*f) (), A1 a1)
+{
+    typedef _mfi::mf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
+}
+
+template<class R, class T,
+    class A1>
+    _bi::bind_t<R, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(R ( T::*f) () const, A1 a1)
+{
+    typedef _mfi::cmf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1));
+}
+
+
+
+template<class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<R, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(R ( T::*f) (B1), A1 a1, A2 a2)
+{
+    typedef _mfi::mf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<R, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(R ( T::*f) (B1) const, A1 a1, A2 a2)
+{
+    typedef _mfi::cmf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::mf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<R, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::cmf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::mf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<R, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<R, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<R, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<R, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<R, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<R, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<R, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 1596 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/bind/bind_mf2_cc.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/bind/bind_mf2_cc.hpp"
+template<class Rt2, class R, class T,
+    class A1>
+    _bi::bind_t<Rt2, _mfi::mf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (), A1 a1)
+{
+    typedef _mfi::mf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+template<class Rt2, class R, class T,
+    class A1>
+    _bi::bind_t<Rt2, _mfi::cmf0<R, T>, typename _bi::list_av_1<A1>::type>
+    bind(boost::type<Rt2>, R ( T::*f) () const, A1 a1)
+{
+    typedef _mfi::cmf0<R, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<Rt2, _mfi::mf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1), A1 a1, A2 a2)
+{
+    typedef _mfi::mf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+template<class Rt2, class R, class T,
+    class B1,
+    class A1, class A2>
+    _bi::bind_t<Rt2, _mfi::cmf1<R, T, B1>, typename _bi::list_av_2<A1, A2>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1) const, A1 a1, A2 a2)
+{
+    typedef _mfi::cmf1<R, T, B1> F;
+    typedef typename _bi::list_av_2<A1, A2>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<Rt2, _mfi::mf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2), A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::mf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2,
+    class A1, class A2, class A3>
+    _bi::bind_t<Rt2, _mfi::cmf2<R, T, B1, B2>, typename _bi::list_av_3<A1, A2, A3>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3)
+{
+    typedef _mfi::cmf2<R, T, B1, B2> F;
+    typedef typename _bi::list_av_3<A1, A2, A3>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<Rt2, _mfi::mf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::mf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3,
+    class A1, class A2, class A3, class A4>
+    _bi::bind_t<Rt2, _mfi::cmf3<R, T, B1, B2, B3>, typename _bi::list_av_4<A1, A2, A3, A4>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4)
+{
+    typedef _mfi::cmf3<R, T, B1, B2, B3> F;
+    typedef typename _bi::list_av_4<A1, A2, A3, A4>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<Rt2, _mfi::mf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::mf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4,
+    class A1, class A2, class A3, class A4, class A5>
+    _bi::bind_t<Rt2, _mfi::cmf4<R, T, B1, B2, B3, B4>, typename _bi::list_av_5<A1, A2, A3, A4, A5>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+{
+    typedef _mfi::cmf4<R, T, B1, B2, B3, B4> F;
+    typedef typename _bi::list_av_5<A1, A2, A3, A4, A5>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<Rt2, _mfi::mf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::mf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5,
+    class A1, class A2, class A3, class A4, class A5, class A6>
+    _bi::bind_t<Rt2, _mfi::cmf5<R, T, B1, B2, B3, B4, B5>, typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+{
+    typedef _mfi::cmf5<R, T, B1, B2, B3, B4, B5> F;
+    typedef typename _bi::list_av_6<A1, A2, A3, A4, A5, A6>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<Rt2, _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::mf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7>
+    _bi::bind_t<Rt2, _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6>, typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+{
+    typedef _mfi::cmf6<R, T, B1, B2, B3, B4, B5, B6> F;
+    typedef typename _bi::list_av_7<A1, A2, A3, A4, A5, A6, A7>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<Rt2, _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::mf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
+    _bi::bind_t<Rt2, _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7>, typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8)
+{
+    typedef _mfi::cmf7<R, T, B1, B2, B3, B4, B5, B6, B7> F;
+    typedef typename _bi::list_av_8<A1, A2, A3, A4, A5, A6, A7, A8>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8));
+}
+
+
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<Rt2, _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::mf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+
+template<class Rt2, class R, class T,
+    class B1, class B2, class B3, class B4, class B5, class B6, class B7, class B8,
+    class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
+    _bi::bind_t<Rt2, _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8>, typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type>
+    bind(boost::type<Rt2>, R ( T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9)
+{
+    typedef _mfi::cmf8<R, T, B1, B2, B3, B4, B5, B6, B7, B8> F;
+    typedef typename _bi::list_av_9<A1, A2, A3, A4, A5, A6, A7, A8, A9>::type list_type;
+    return _bi::bind_t<Rt2, F, list_type>(F(f), list_type(a1, a2, a3, a4, a5, a6, a7, a8, a9));
+}
+# 1597 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+# 1656 "/usr/include/boost-1_42/boost/bind/bind.hpp"
+namespace _bi
+{
+
+template< class Pm, int I > struct add_cref;
+
+template< class M, class T > struct add_cref< M T::*, 0 >
+{
+    typedef M type;
+};
+
+template< class M, class T > struct add_cref< M T::*, 1 >
+{
+
+
+
+
+    typedef M const & type;
+
+
+
+};
+
+template< class R, class T > struct add_cref< R (T::*) (), 1 >
+{
+    typedef void type;
+};
+
+
+
+template< class R, class T > struct add_cref< R (T::*) () const, 1 >
+{
+    typedef void type;
+};
+
+
+
+template<class R> struct isref
+{
+    enum value_type { value = 0 };
+};
+
+template<class R> struct isref< R& >
+{
+    enum value_type { value = 1 };
+};
+
+template<class R> struct isref< R* >
+{
+    enum value_type { value = 1 };
+};
+
+template<class Pm, class A1> struct dm_result
+{
+    typedef typename add_cref< Pm, 1 >::type type;
+};
+
+template<class Pm, class R, class F, class L> struct dm_result< Pm, bind_t<R, F, L> >
+{
+    typedef typename bind_t<R, F, L>::result_type result_type;
+    typedef typename add_cref< Pm, isref< result_type >::value >::type type;
+};
+
+}
+
+template< class A1, class M, class T >
+
+_bi::bind_t<
+    typename _bi::dm_result< M T::*, A1 >::type,
+    _mfi::dm<M, T>,
+    typename _bi::list_av_1<A1>::type
+>
+
+bind( M T::*f, A1 a1 )
+{
+    typedef typename _bi::dm_result< M T::*, A1 >::type result_type;
+    typedef _mfi::dm<M, T> F;
+    typedef typename _bi::list_av_1<A1>::type list_type;
+    return _bi::bind_t< result_type, F, list_type >( F( f ), list_type( a1 ) );
+}
+
+
+
+}
+
+
+
+# 1 "/usr/include/boost-1_42/boost/bind/placeholders.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/bind/placeholders.hpp"
+namespace
+{
+# 55 "/usr/include/boost-1_42/boost/bind/placeholders.hpp"
+boost::arg<1> _1;
+boost::arg<2> _2;
+boost::arg<3> _3;
+boost::arg<4> _4;
+boost::arg<5> _5;
+boost::arg<6> _6;
+boost::arg<7> _7;
+boost::arg<8> _8;
+boost::arg<9> _9;
+
+
+
+}
+# 1743 "/usr/include/boost-1_42/boost/bind/bind.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/bind.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/python/exception_translator.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp" 1
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/function0.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/function/function0.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/function/function0.hpp" 2
+# 10 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/function/function2.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/function/function2.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/function/function2.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/python/detail/exception_handler.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+struct exception_handler;
+
+typedef function2<bool, exception_handler const&, function0<void> const&> handler_function;
+
+struct exception_handler
+{
+ private:
+
+ public:
+    explicit exception_handler(handler_function const& impl);
+
+    inline bool handle(function0<void> const& f) const;
+
+    bool operator()(function0<void> const& f) const;
+
+    static exception_handler* chain;
+
+ private:
+    static exception_handler* tail;
+
+    handler_function m_impl;
+    exception_handler* m_next;
+};
+
+
+inline bool exception_handler::handle(function0<void> const& f) const
+{
+    return this->m_impl(*this, f);
+}
+
+ void register_exception_handler(handler_function const& f);
+
+}}}
+# 9 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/function/function0.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/function/function0.hpp"
+# 1 "/usr/include/boost-1_42/boost/function/detail/maybe_include.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/function/function0.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+
+
+
+
+template <class ExceptionType, class Translate>
+struct translate_exception
+{
+# 36 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp"
+    typedef typename add_reference<
+        typename add_const<ExceptionType>::type
+    >::type exception_cref;
+
+
+    inline bool operator()(
+        exception_handler const& handler
+      , function0<void> const& f
+      , typename call_traits<Translate>::param_type translate) const
+    {
+        try
+        {
+            return handler(f);
+        }
+# 58 "/usr/include/boost-1_42/boost/python/detail/translate_exception.hpp"
+        catch(exception_cref e)
+
+        {
+            translate(e);
+            return true;
+        }
+    }
+};
+
+}}}
+# 13 "/usr/include/boost-1_42/boost/python/exception_translator.hpp" 2
+
+
+namespace boost { namespace python {
+
+template <class ExceptionType, class Translate>
+void register_exception_translator(Translate translate, boost::type<ExceptionType>* = 0)
+{
+    detail::register_exception_handler(
+        bind<bool>(detail::translate_exception<ExceptionType,Translate>(), _1, _2, translate)
+        );
+}
+
+}}
+# 29 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/exec.hpp" 1
+# 9 "/usr/include/boost-1_42/boost/python/exec.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/str.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/python/str.hpp"
+namespace boost { namespace python {
+
+class str;
+
+namespace detail
+{
+  struct str_base : object
+  {
+      str capitalize() const;
+
+      str center(object_cref width) const;
+
+      long count(object_cref sub) const;
+
+      long count(object_cref sub, object_cref start) const;
+
+      long count(object_cref sub, object_cref start, object_cref end) const;
+
+
+      object decode() const;
+      object decode(object_cref encoding) const;
+
+      object decode(object_cref encoding, object_cref errors) const;
+
+
+      object encode() const;
+      object encode(object_cref encoding) const;
+      object encode(object_cref encoding, object_cref errors) const;
+
+      bool endswith(object_cref suffix) const;
+
+      bool endswith(object_cref suffix, object_cref start) const;
+      bool endswith(object_cref suffix, object_cref start, object_cref end) const;
+
+      str expandtabs() const;
+      str expandtabs(object_cref tabsize) const;
+
+      long find(object_cref sub) const;
+      long find(object_cref sub, object_cref start) const;
+
+      long find(object_cref sub, object_cref start, object_cref end) const;
+
+      long index(object_cref sub) const;
+
+      long index(object_cref sub, object_cref start) const;
+      long index(object_cref sub, object_cref start, object_cref end) const;
+
+      bool isalnum() const;
+      bool isalpha() const;
+      bool isdigit() const;
+      bool islower() const;
+      bool isspace() const;
+      bool istitle() const;
+      bool isupper() const;
+
+      str join(object_cref sequence) const;
+
+      str ljust(object_cref width) const;
+      str lower() const;
+      str lstrip() const;
+
+      str replace(object_cref old, object_cref new_) const;
+      str replace(object_cref old, object_cref new_, object_cref maxsplit) const;
+      long rfind(object_cref sub) const;
+
+      long rfind(object_cref sub, object_cref start) const;
+
+      long rfind(object_cref sub, object_cref start, object_cref end) const;
+      long rindex(object_cref sub) const;
+      long rindex(object_cref sub, object_cref start) const;
+
+
+      long rindex(object_cref sub, object_cref start, object_cref end) const;
+
+      str rjust(object_cref width) const;
+
+      str rstrip() const;
+
+      list split() const;
+      list split(object_cref sep) const;
+
+      list split(object_cref sep, object_cref maxsplit) const;
+
+
+      list splitlines() const;
+      list splitlines(object_cref keepends) const;
+
+      bool startswith(object_cref prefix) const;
+
+
+      bool startswith(object_cref prefix, object_cref start) const;
+      bool startswith(object_cref prefix, object_cref start, object_cref end) const;
+
+      str strip() const;
+      str swapcase() const;
+      str title() const;
+
+      str translate(object_cref table) const;
+
+      str translate(object_cref table, object_cref deletechars) const;
+
+
+      str upper() const;
+
+   protected:
+      str_base();
+
+      str_base(const char* s);
+
+      str_base(char const* start, char const* finish);
+
+      str_base(char const* start, std::size_t length);
+
+      explicit str_base(object_cref other);
+
+      inline explicit str_base(python::detail::borrowed_reference p) : object(p) {} inline explicit str_base(python::detail::new_reference p) : object(p) {} inline explicit str_base(python::detail::new_non_null_reference p) : object(p) {}
+   private:
+      static new_reference call(object const&);
+  };
+}
+
+
+class str : public detail::str_base
+{
+    typedef detail::str_base base;
+ public:
+    str() {}
+
+    str(const char* s) : base(s) {}
+
+    str(char const* start, char const* finish)
+      : base(start, finish)
+    {}
+
+    str(char const* start, std::size_t length)
+      : base(start, length)
+    {}
+
+    template <class T>
+    explicit str(T const& other)
+        : base(object(other))
+    {
+    }
+
+    template <class T>
+    str center(T const& width) const
+    {
+        return base::center(object(width));
+    }
+
+    template<class T>
+    long count(T const& sub) const
+    {
+        return base::count(object(sub));
+    }
+
+    template<class T1, class T2>
+    long count(T1 const& sub,T2 const& start) const
+    {
+        return base::count(object(sub), object(start));
+    }
+
+    template<class T1, class T2, class T3>
+    long count(T1 const& sub,T2 const& start, T3 const& end) const
+    {
+        return base::count(object(sub), object(start));
+    }
+
+
+    object decode() const { return base::decode(); }
+
+    template<class T>
+    object decode(T const& encoding) const
+    {
+        return base::decode(object(encoding));
+    }
+
+    template<class T1, class T2>
+    object decode(T1 const& encoding, T2 const& errors) const
+    {
+        return base::decode(object(encoding),object(errors));
+    }
+
+
+    object encode() const { return base::encode(); }
+
+    template <class T>
+    object encode(T const& encoding) const
+    {
+        return base::encode(object(encoding));
+    }
+
+    template <class T1, class T2>
+    object encode(T1 const& encoding, T2 const& errors) const
+    {
+        return base::encode(object(encoding),object(errors));
+    }
+
+    template <class T>
+    bool endswith(T const& suffix) const
+    {
+        return base::endswith(object(suffix));
+    }
+
+    template <class T1, class T2>
+    bool endswith(T1 const& suffix, T2 const& start) const
+    {
+        return base::endswith(object(suffix), object(start));
+    }
+
+    template <class T1, class T2, class T3>
+    bool endswith(T1 const& suffix, T2 const& start, T3 const& end) const
+    {
+        return base::endswith(object(suffix), object(start), object(end));
+    }
+
+    str expandtabs() const { return base::expandtabs(); }
+
+    template <class T>
+    str expandtabs(T const& tabsize) const
+    {
+        return base::expandtabs(object(tabsize));
+    }
+
+    template <class T>
+    long find(T const& sub) const
+    {
+        return base::find(object(sub));
+    }
+
+    template <class T1, class T2>
+    long find(T1 const& sub, T2 const& start) const
+    {
+        return base::find(object(sub), object(start));
+    }
+
+    template <class T1, class T2, class T3>
+    long find(T1 const& sub, T2 const& start, T3 const& end) const
+    {
+        return base::find(object(sub), object(start), object(end));
+    }
+
+    template <class T>
+    long index(T const& sub) const
+    {
+        return base::index(object(sub));
+    }
+
+    template <class T1, class T2>
+    long index(T1 const& sub, T2 const& start) const
+    {
+        return base::index(object(sub), object(start));
+    }
+
+    template <class T1, class T2, class T3>
+    long index(T1 const& sub, T2 const& start, T3 const& end) const
+    {
+        return base::index(object(sub), object(start), object(end));
+    }
+
+    template <class T>
+    str join(T const& sequence) const
+    {
+        return base::join(object(sequence));
+    }
+
+    template <class T>
+    str ljust(T const& width) const
+    {
+        return base::ljust(object(width));
+    }
+
+    template <class T1, class T2>
+    str replace(T1 const& old, T2 const& new_) const
+    {
+        return base::replace(object(old),object(new_));
+    }
+
+    template <class T1, class T2, class T3>
+    str replace(T1 const& old, T2 const& new_, T3 const& maxsplit) const
+    {
+        return base::replace(object(old),object(new_), object(maxsplit));
+    }
+
+    template <class T>
+    long rfind(T const& sub) const
+    {
+        return base::rfind(object(sub));
+    }
+
+    template <class T1, class T2>
+    long rfind(T1 const& sub, T2 const& start) const
+    {
+        return base::rfind(object(sub), object(start));
+    }
+
+    template <class T1, class T2, class T3>
+    long rfind(T1 const& sub, T2 const& start, T3 const& end) const
+    {
+        return base::rfind(object(sub), object(start), object(end));
+    }
+
+    template <class T>
+    long rindex(T const& sub) const
+    {
+        return base::rindex(object(sub));
+    }
+
+    template <class T1, class T2>
+    long rindex(T1 const& sub, T2 const& start) const
+    {
+        return base::rindex(object(sub), object(start));
+    }
+
+    template <class T1, class T2, class T3>
+    long rindex(T1 const& sub, T2 const& start, T3 const& end) const
+    {
+        return base::rindex(object(sub), object(start), object(end));
+    }
+
+    template <class T>
+    str rjust(T const& width) const
+    {
+        return base::rjust(object(width));
+    }
+
+    list split() const { return base::split(); }
+
+    template <class T>
+    list split(T const& sep) const
+    {
+        return base::split(object(sep));
+    }
+
+    template <class T1, class T2>
+    list split(T1 const& sep, T2 const& maxsplit) const
+    {
+        return base::split(object(sep), object(maxsplit));
+    }
+
+    list splitlines() const { return base::splitlines(); }
+
+    template <class T>
+    list splitlines(T const& keepends) const
+    {
+        return base::splitlines(object(keepends));
+    }
+
+    template <class T>
+    bool startswith(T const& prefix) const
+    {
+        return base::startswith(object(prefix));
+    }
+
+    template <class T1, class T2>
+    bool startswith(T1 const& prefix, T2 const& start) const
+    {
+        return base::startswith(object(prefix), object(start));
+    }
+
+    template <class T1, class T2, class T3>
+    bool startswith(T1 const& prefix, T2 const& start, T3 const& end) const
+    {
+        return base::startswith(object(prefix), object(start), object(end));
+    }
+
+    template <class T>
+    str translate(T const& table) const
+    {
+        return base::translate(object(table));
+    }
+
+    template <class T1, class T2>
+    str translate(T1 const& table, T2 const& deletechars) const
+    {
+        return base::translate(object(table), object(deletechars));
+    }
+
+ public:
+    inline explicit str(python::detail::borrowed_reference p) : base(p) {} inline explicit str(python::detail::new_reference p) : base(p) {} inline explicit str(python::detail::new_non_null_reference p) : base(p) {}
+};
+
+
+
+
+namespace converter
+{
+  template <>
+  struct object_manager_traits<str>
+
+
+
+      : pytype_object_manager_traits<&PyString_Type,str>
+
+  {
+  };
+}
+
+}}
+# 10 "/usr/include/boost-1_42/boost/python/exec.hpp" 2
+
+namespace boost
+{
+namespace python
+{
+
+
+
+
+object
+
+eval(str string, object global = object(), object local = object());
+
+
+
+
+object
+
+exec_statement(str string, object global = object(), object local = object());
+
+
+
+
+object
+
+exec(str string, object global = object(), object local = object());
+
+
+
+
+object
+
+exec_file(str filename, object global = object(), object local = object());
+
+}
+}
+# 30 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/implicit.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/implicit.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/converter/implicit.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/converter/implicit.hpp"
+namespace boost { namespace python { namespace converter {
+
+template <class Source, class Target>
+struct implicit
+{
+    static void* convertible(PyObject* obj)
+    {
+
+
+
+
+        return implicit_rvalue_convertible_from_python(obj, registered<Source>::converters)
+            ? obj : 0;
+    }
+
+    static void construct(PyObject* obj, rvalue_from_python_stage1_data* data)
+    {
+        void* storage = ((rvalue_from_python_storage<Target>*)data)->storage.bytes;
+
+        arg_from_python<Source> get_source(obj);
+        bool convertible = get_source.convertible();
+        ((void)(convertible));
+
+        new (storage) Target(get_source());
+
+
+        data->convertible = storage;
+    }
+};
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/implicit.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace python {
+
+template <class Source, class Target>
+void implicitly_convertible(boost::type<Source>* = 0, boost::type<Target>* = 0)
+{
+    typedef converter::implicit<Source,Target> functions;
+
+    converter::registry::push_back(
+          &functions::convertible
+        , &functions::construct
+        , type_id<Target>()
+
+        , &converter::expected_from_python_type_direct<Source>::get_pytype
+
+        );
+}
+
+}}
+# 34 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/import.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/import.hpp"
+namespace boost
+{
+namespace python
+{
+
+
+object import(str name);
+
+}
+}
+# 36 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/iterator.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+namespace boost { namespace python { namespace detail {
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R >
+void(* target(R (*)()) )()
+{
+    return 0;
+}
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0>
+A0(* target(R (*)( A0)) )()
+{
+    return 0;
+}
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1>
+A0(* target(R (*)( A0 , A1)) )()
+{
+    return 0;
+}
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2>
+A0(* target(R (*)( A0 , A1 , A2)) )()
+{
+    return 0;
+}
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3>
+A0(* target(R (*)( A0 , A1 , A2 , A3)) )()
+{
+    return 0;
+}
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4)) )()
+{
+    return 0;
+}
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5)) )()
+{
+    return 0;
+}
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6)) )()
+{
+    return 0;
+}
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)) )()
+{
+    return 0;
+}
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)) )()
+{
+    return 0;
+}
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)) )()
+{
+    return 0;
+}
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10)) )()
+{
+    return 0;
+}
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11)) )()
+{
+    return 0;
+}
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12)) )()
+{
+    return 0;
+}
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13)) )()
+{
+    return 0;
+}
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 46 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+template <class R , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+A0(* target(R (*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14)) )()
+{
+    return 0;
+}
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T >
+T& (* target(R (T::*)() ) )()
+{
+    return 0;
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0>
+T& (* target(R (T::*)( A0) ) )()
+{
+    return 0;
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1>
+T& (* target(R (T::*)( A0 , A1) ) )()
+{
+    return 0;
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2>
+T& (* target(R (T::*)( A0 , A1 , A2) ) )()
+{
+    return 0;
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3) ) )()
+{
+    return 0;
+}
+# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) ) )()
+{
+    return 0;
+}
+# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) ) )()
+{
+    return 0;
+}
+# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) ) )()
+{
+    return 0;
+}
+# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) ) )()
+{
+    return 0;
+}
+# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) ) )()
+{
+    return 0;
+}
+# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) ) )()
+{
+    return 0;
+}
+# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) ) )()
+{
+    return 0;
+}
+# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) ) )()
+{
+    return 0;
+}
+# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) ) )()
+{
+    return 0;
+}
+# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) ) )()
+{
+    return 0;
+}
+# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) ) )()
+{
+    return 0;
+}
+# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T >
+T& (* target(R (T::*)() const) )()
+{
+    return 0;
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0>
+T& (* target(R (T::*)( A0) const) )()
+{
+    return 0;
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1>
+T& (* target(R (T::*)( A0 , A1) const) )()
+{
+    return 0;
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2>
+T& (* target(R (T::*)( A0 , A1 , A2) const) )()
+{
+    return 0;
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3) const) )()
+{
+    return 0;
+}
+# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) const) )()
+{
+    return 0;
+}
+# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) const) )()
+{
+    return 0;
+}
+# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) const) )()
+{
+    return 0;
+}
+# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const) )()
+{
+    return 0;
+}
+# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const) )()
+{
+    return 0;
+}
+# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const) )()
+{
+    return 0;
+}
+# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) const) )()
+{
+    return 0;
+}
+# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) const) )()
+{
+    return 0;
+}
+# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) const) )()
+{
+    return 0;
+}
+# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) const) )()
+{
+    return 0;
+}
+# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) const) )()
+{
+    return 0;
+}
+# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T >
+T& (* target(R (T::*)() volatile) )()
+{
+    return 0;
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0>
+T& (* target(R (T::*)( A0) volatile) )()
+{
+    return 0;
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1>
+T& (* target(R (T::*)( A0 , A1) volatile) )()
+{
+    return 0;
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2>
+T& (* target(R (T::*)( A0 , A1 , A2) volatile) )()
+{
+    return 0;
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3) volatile) )()
+{
+    return 0;
+}
+# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) volatile) )()
+{
+    return 0;
+}
+# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) volatile) )()
+{
+    return 0;
+}
+# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) volatile) )()
+{
+    return 0;
+}
+# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) volatile) )()
+{
+    return 0;
+}
+# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) volatile) )()
+{
+    return 0;
+}
+# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) volatile) )()
+{
+    return 0;
+}
+# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) volatile) )()
+{
+    return 0;
+}
+# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) volatile) )()
+{
+    return 0;
+}
+# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) volatile) )()
+{
+    return 0;
+}
+# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) volatile) )()
+{
+    return 0;
+}
+# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) volatile) )()
+{
+    return 0;
+}
+# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 64 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower2.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper2.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T >
+T& (* target(R (T::*)() const volatile) )()
+{
+    return 0;
+}
+# 46 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0>
+T& (* target(R (T::*)( A0) const volatile) )()
+{
+    return 0;
+}
+# 51 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1>
+T& (* target(R (T::*)( A0 , A1) const volatile) )()
+{
+    return 0;
+}
+# 56 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2>
+T& (* target(R (T::*)( A0 , A1 , A2) const volatile) )()
+{
+    return 0;
+}
+# 61 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3) const volatile) )()
+{
+    return 0;
+}
+# 66 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4) const volatile) )()
+{
+    return 0;
+}
+# 71 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5) const volatile) )()
+{
+    return 0;
+}
+# 76 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6) const volatile) )()
+{
+    return 0;
+}
+# 81 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7) const volatile) )()
+{
+    return 0;
+}
+# 86 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8) const volatile) )()
+{
+    return 0;
+}
+# 91 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9) const volatile) )()
+{
+    return 0;
+}
+# 96 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10) const volatile) )()
+{
+    return 0;
+}
+# 101 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11) const volatile) )()
+{
+    return 0;
+}
+# 106 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12) const volatile) )()
+{
+    return 0;
+}
+# 111 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13) const volatile) )()
+{
+    return 0;
+}
+# 116 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/python/detail/target.hpp"
+
+
+
+
+
+
+template <class R, class T , class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14>
+T& (* target(R (T::*)( A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9 , A10 , A11 , A12 , A13 , A14) const volatile) )()
+{
+    return 0;
+}
+# 121 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward2.hpp" 2
+# 65 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 31 "/usr/include/boost-1_42/boost/python/detail/target.hpp" 2
+
+template <class R, class T>
+T& (* target(R (T::*)) )() { return 0; }
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/object/iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/iterator_core.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/object/iterator_core.hpp"
+namespace boost { namespace python { namespace objects {
+
+ object const& identity_function();
+ void stop_iteration_error();
+
+}}}
+# 17 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/class_detail.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/object/class_detail.hpp"
+namespace boost { namespace python { namespace objects {
+
+ type_handle registered_class_object(type_info id);
+ type_handle class_metatype();
+ type_handle class_type();
+
+}}}
+# 18 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 2
+# 31 "/usr/include/boost-1_42/boost/python/object/iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/detail/iterator.hpp" 1
+# 77 "/usr/include/boost-1_42/boost/detail/iterator.hpp"
+namespace boost { namespace detail {
+
+
+template <class Iterator>
+struct iterator_traits
+    : std::iterator_traits<Iterator>
+{};
+using std::distance;
+
+}}
+# 32 "/usr/include/boost-1_42/boost/python/object/iterator.hpp" 2
+
+namespace boost { namespace python { namespace objects {
+
+
+
+
+
+
+typedef return_value_policy<return_by_value> default_iterator_call_policies;
+
+
+template <class NextPolicies, class Iterator>
+struct iterator_range
+{
+    iterator_range(object sequence, Iterator start, Iterator finish);
+
+    typedef boost::detail::iterator_traits<Iterator> traits_t;
+
+    struct next
+    {
+        typedef typename mpl::if_<
+            is_reference<
+                typename traits_t::reference
+            >
+          , typename traits_t::reference
+          , typename traits_t::value_type
+        >::type result_type;
+
+        result_type
+        operator()(iterator_range<NextPolicies,Iterator>& self)
+        {
+            if (self.m_start == self.m_finish)
+                stop_iteration_error();
+            return *self.m_start++;
+        }
+
+
+
+
+
+    };
+# 101 "/usr/include/boost-1_42/boost/python/object/iterator.hpp"
+    typedef next next_fn;
+
+
+    object m_sequence;
+    Iterator m_start;
+    Iterator m_finish;
+};
+
+namespace detail
+{
+
+
+
+  template <class Iterator, class NextPolicies>
+  object demand_iterator_class(char const* name, Iterator* = 0, NextPolicies const& policies = NextPolicies())
+  {
+      typedef iterator_range<NextPolicies,Iterator> range_;
+
+
+      handle<> class_obj(
+          objects::registered_class_object(python::type_id<range_>()));
+
+      if (class_obj.get() != 0)
+          return object(class_obj);
+
+      typedef typename range_::next_fn next_fn;
+      typedef typename next_fn::result_type result_type;
+
+      return class_<range_>(name, no_init)
+          .def("__iter__", identity_function())
+          .def(
+
+
+
+              "next"
+
+            , make_function(
+                next_fn()
+              , policies
+              , mpl::vector2<result_type,range_&>()
+            ));
+  }
+
+
+  template <
+      class Target
+    , class Iterator
+    , class Accessor1
+    , class Accessor2
+    , class NextPolicies
+  >
+  struct py_iter_
+  {
+      py_iter_(Accessor1 const& get_start, Accessor2 const& get_finish)
+        : m_get_start(get_start)
+        , m_get_finish(get_finish)
+      {}
+
+
+
+
+
+      iterator_range<NextPolicies,Iterator>
+      operator()(back_reference<Target&> x) const
+      {
+
+          detail::demand_iterator_class("iterator", (Iterator*)0, NextPolicies());
+
+          return iterator_range<NextPolicies,Iterator>(
+              x.source()
+            , m_get_start(x.get())
+            , m_get_finish(x.get())
+          );
+      }
+   private:
+      Accessor1 m_get_start;
+      Accessor2 m_get_finish;
+  };
+
+  template <class Target, class Iterator, class NextPolicies, class Accessor1, class Accessor2>
+  inline object make_iterator_function(
+      Accessor1 const& get_start
+    , Accessor2 const& get_finish
+    , NextPolicies const&
+    , Iterator const& (*)()
+    , boost::type<Target>*
+    , int
+  )
+  {
+      return make_function(
+          py_iter_<Target,Iterator,Accessor1,Accessor2,NextPolicies>(get_start, get_finish)
+        , default_call_policies()
+        , mpl::vector2<iterator_range<NextPolicies,Iterator>, back_reference<Target&> >()
+      );
+  }
+
+  template <class Target, class Iterator, class NextPolicies, class Accessor1, class Accessor2>
+  inline object make_iterator_function(
+      Accessor1 const& get_start
+    , Accessor2 const& get_finish
+    , NextPolicies const& next_policies
+    , Iterator& (*)()
+    , boost::type<Target>*
+    , ...)
+  {
+      return make_iterator_function(
+          get_start
+        , get_finish
+        , next_policies
+        , (Iterator const&(*)())0
+        , (boost::type<Target>*)0
+        , 0
+      );
+  }
+
+}
+
+
+
+
+
+
+
+template <class Target, class NextPolicies, class Accessor1, class Accessor2>
+inline object make_iterator_function(
+    Accessor1 const& get_start
+  , Accessor2 const& get_finish
+  , NextPolicies const& next_policies
+  , boost::type<Target>* = 0
+)
+{
+    typedef typename Accessor1::result_type iterator;
+    typedef typename add_const<iterator>::type iterator_const;
+    typedef typename add_reference<iterator_const>::type iterator_cref;
+
+    return detail::make_iterator_function(
+        get_start
+      , get_finish
+      , next_policies
+      , (iterator_cref(*)())0
+      , (boost::type<Target>*)0
+      , 0
+    );
+}
+
+
+
+
+template <class NextPolicies, class Iterator>
+inline iterator_range<NextPolicies,Iterator>::iterator_range(
+    object sequence, Iterator start, Iterator finish)
+    : m_sequence(sequence), m_start(start), m_finish(finish)
+{
+}
+
+}}}
+# 12 "/usr/include/boost-1_42/boost/python/iterator.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/python/iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/bind/protect.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/bind/protect.hpp"
+namespace boost
+{
+
+namespace _bi
+{
+
+template<class F> class protected_bind_t
+{
+public:
+
+    typedef typename F::result_type result_type;
+
+    explicit protected_bind_t(F f): f_(f)
+    {
+    }
+
+    result_type operator()()
+    {
+        return f_();
+    }
+
+    result_type operator()() const
+    {
+        return f_();
+    }
+
+    template<class A1> result_type operator()(A1 & a1)
+    {
+        return f_(a1);
+    }
+
+    template<class A1> result_type operator()(A1 & a1) const
+    {
+        return f_(a1);
+    }
+
+
+
+
+
+    template<class A1> result_type operator()(const A1 & a1)
+    {
+        return f_(a1);
+    }
+
+    template<class A1> result_type operator()(const A1 & a1) const
+    {
+        return f_(a1);
+    }
+
+
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
+    {
+        return f_(a1, a2);
+    }
+
+
+
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
+    {
+        return f_(a1, a2);
+    }
+
+
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
+    {
+        return f_(a1, a2, a3);
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
+    {
+        return f_(a1, a2, a3);
+    }
+
+
+
+
+    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
+    {
+        return f_(a1, a2, a3);
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
+    {
+        return f_(a1, a2, a3);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
+    {
+        return f_(a1, a2, a3, a4, a5);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
+    {
+        return f_(a1, a2, a3, a4, a5);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
+    {
+        return f_(a1, a2, a3, a4, a5);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
+    {
+        return f_(a1, a2, a3, a4, a5);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
+    {
+        return f_(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
+    {
+        return f_(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+
+
+
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+
+
+
+private:
+
+    F f_;
+};
+
+}
+
+template<class F> _bi::protected_bind_t<F> protect(F f)
+{
+    return _bi::protected_bind_t<F>(f);
+}
+
+}
+# 29 "/usr/include/boost-1_42/boost/python/iterator.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+
+  template <class Target, class Accessor1, class Accessor2, class NextPolicies>
+  inline object make_iterator(
+      Accessor1 get_start
+    , Accessor2 get_finish
+    , NextPolicies next_policies
+    , Target&(*)()
+  )
+  {
+      return objects::make_iterator_function<Target>(
+          boost::protect(boost::bind(get_start, _1))
+        , boost::protect(boost::bind(get_finish, _1))
+        , next_policies
+      );
+  }
+
+
+  template <bool const_ = false>
+  struct iterators_impl
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::iterator iterator;
+          static iterator begin(T& x) { return x.begin(); }
+          static iterator end(T& x) { return x.end(); }
+      };
+  };
+
+  template <>
+  struct iterators_impl<true>
+  {
+      template <class T>
+      struct apply
+      {
+          typedef typename T::const_iterator iterator;
+          static iterator begin(T& x) { return x.begin(); }
+          static iterator end(T& x) { return x.end(); }
+      };
+  };
+}
+
+
+
+template <class T>
+struct iterators
+    : detail::iterators_impl<
+        boost::is_const<T>::value
+      >::template apply<T>
+{
+};
+
+
+
+
+template <class Accessor1, class Accessor2>
+object range(Accessor1 start, Accessor2 finish)
+{
+    return detail::make_iterator(
+        start, finish
+      , objects::default_iterator_call_policies()
+      , detail::target(start)
+    );
+}
+
+
+
+template <class NextPolicies, class Accessor1, class Accessor2>
+object range(Accessor1 start, Accessor2 finish, NextPolicies* = 0)
+{
+    return detail::make_iterator(start, finish, NextPolicies(), detail::target(start));
+}
+
+
+
+template <class NextPolicies, class Target, class Accessor1, class Accessor2>
+object range(Accessor1 start, Accessor2 finish, NextPolicies* = 0, boost::type<Target>* = 0)
+{
+
+    return detail::make_iterator(start, finish, NextPolicies(), (Target&(*)())0);
+}
+
+
+
+
+
+template <class Container
+          , class NextPolicies = objects::default_iterator_call_policies>
+struct iterator : object
+{
+    iterator()
+        : object(
+            python::range<NextPolicies>(
+                &iterators<Container>::begin, &iterators<Container>::end
+                ))
+    {
+    }
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/long.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/long.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  struct long_base : object
+  {
+   protected:
+      long_base();
+      explicit long_base(object_cref rhs);
+      explicit long_base(object_cref rhs, object_cref base);
+
+      inline explicit long_base(python::detail::borrowed_reference p) : object(p) {} inline explicit long_base(python::detail::new_reference p) : object(p) {} inline explicit long_base(python::detail::new_non_null_reference p) : object(p) {}
+
+   private:
+      static detail::new_non_null_reference call(object const&);
+      static detail::new_non_null_reference call(object const&, object const&);
+  };
+}
+
+class long_ : public detail::long_base
+{
+    typedef detail::long_base base;
+ public:
+    long_() {}
+
+    template <class T>
+    explicit long_(T const& rhs)
+        : detail::long_base(object(rhs))
+    {
+    }
+
+    template <class T, class U>
+    explicit long_(T const& rhs, U const& base)
+        : detail::long_base(object(rhs), object(base))
+    {
+    }
+
+ public:
+    inline explicit long_(python::detail::borrowed_reference p) : base(p) {} inline explicit long_(python::detail::new_reference p) : base(p) {} inline explicit long_(python::detail::new_non_null_reference p) : base(p) {}
+};
+
+
+
+
+namespace converter
+{
+  template <>
+  struct object_manager_traits<long_>
+      : pytype_object_manager_traits<&PyLong_Type,long_>
+  {
+  };
+}
+
+}}
+# 40 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/lvalue_from_pytype.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/python/lvalue_from_pytype.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+  template <class T, class U>
+  inline type_info extractor_type_id(T&(*)(U))
+  {
+      return type_id<T>();
+  }
+
+
+
+
+
+  template <class Extractor, class U>
+  struct normalized_extractor
+  {
+      static inline void* execute(PyObject* op)
+      {
+          typedef typename boost::add_reference<U>::type param;
+          return &Extractor::execute(
+              boost::python::detail::void_ptr_to_reference(
+                  op, (param(*)())0 )
+              );
+      }
+  };
+
+
+
+
+
+
+  template <class Extractor, class T, class U>
+  inline normalized_extractor<Extractor,U>
+  normalize(T(*)(U), Extractor* = 0)
+  {
+      return normalized_extractor<Extractor, U>();
+  }
+}
+
+
+
+template <class InstanceType, class MemberType, MemberType (InstanceType::*member)>
+struct extract_member
+{
+    static MemberType& execute(InstanceType& c)
+    {
+        (void)(((PyObject*)(&c))->ob_type);
+        return c.*member;
+    }
+};
+
+
+
+template <class InstanceType>
+struct extract_identity
+{
+    static InstanceType& execute(InstanceType& c)
+    {
+        (void)(((PyObject*)(&c))->ob_type);
+        return c;
+    }
+};
+
+
+
+
+template <class Extractor, PyTypeObject const* python_type>
+struct lvalue_from_pytype
+{
+    lvalue_from_pytype()
+    {
+        converter::registry::insert
+            ( &extract
+            , detail::extractor_type_id(&Extractor::execute)
+
+            , &get_pytype
+
+            );
+    }
+ private:
+    static void* extract(PyObject* op)
+    {
+        return ((((PyObject*)(op))->ob_type) == (const_cast<PyTypeObject*>(python_type)) || PyType_IsSubtype((((PyObject*)(op))->ob_type), (const_cast<PyTypeObject*>(python_type))))
+            ? const_cast<void*>(
+                static_cast<void const volatile*>(
+                    detail::normalize<Extractor>(&Extractor::execute).execute(op)))
+            : 0
+            ;
+    }
+
+    static PyTypeObject const*get_pytype() { return python_type; }
+
+};
+
+}}
+# 41 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/make_holder.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/object/pointer_holder.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/caller.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/push_front.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/push_front.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp"
+namespace boost { namespace mpl {
+
+struct has_push_front_arg {};
+
+
+
+
+template< typename Tag >
+struct push_front_impl
+{
+    template< typename Sequence, typename T > struct apply
+    {
+
+
+
+        struct REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST; typedef struct
+
+
+
+ REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST45
+# 41 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp"
+        : boost::mpl::assert_ { static boost::mpl::failed ************ (REQUESTED_PUSH_FRONT_SPECIALIZATION_FOR_SEQUENCE_DOES_NOT_EXIST::************ assert_arg()) ( Sequence ) { return 0; } }
+
+
+
+ mpl_assert_arg45
+# 41 "/usr/include/boost-1_42/boost/mpl/aux_/push_front_impl.hpp"
+        ; enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<(( boost::is_same< T, has_push_front_arg >::value ))>( mpl_assert_arg45::assert_arg() ) ) }
+
+
+
+             ;
+    };
+};
+
+template< typename Tag >
+struct has_push_front_impl
+{
+    template< typename Seq > struct apply
+
+        : aux::has_type< push_front< Seq, has_push_front_arg > >
+    {
+
+
+
+
+
+
+
+    };
+};
+
+ template<> struct push_front_impl<non_sequence_tag> {};
+ template<> struct has_push_front_impl<non_sequence_tag> {};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/push_front.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    , typename T = na
+    >
+struct push_front
+    : push_front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence,T >
+{
+   
+};
+
+
+template<
+      typename Sequence = na
+    >
+struct has_push_front
+    : has_push_front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+   
+};
+
+template<> struct push_front< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : push_front< T1 , T2 > { }; }; template< typename Tag > struct lambda< push_front< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef push_front< na , na > result_; typedef push_front< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< push_front< T1 , T2 > > : int_<2> { }; template<> struct template_arity< push_front< na , na > > : int_<-1> { }; }
+template<> struct has_push_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : has_push_front< T1 > { }; }; template< typename Tag > struct lambda< has_push_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef has_push_front< na > result_; typedef has_push_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< has_push_front< T1 > > : int_<1> { }; template<> struct template_arity< has_push_front< na > > : int_<-1> { }; }
+
+}}
+# 25 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/pop_front.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/mpl/pop_front.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/pop_front_impl.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/pop_front_impl.hpp"
+namespace boost { namespace mpl {
+
+
+
+template< typename Tag >
+struct pop_front_impl
+{
+    template< typename Sequence > struct apply
+
+
+
+
+
+
+
+    ;
+};
+
+ template<> struct pop_front_impl<non_sequence_tag> {};
+
+}}
+# 19 "/usr/include/boost-1_42/boost/mpl/pop_front.hpp" 2
+
+
+
+
+namespace boost { namespace mpl {
+
+template<
+      typename Sequence = na
+    >
+struct pop_front
+    : pop_front_impl< typename sequence_tag<Sequence>::type >
+        ::template apply< Sequence >
+{
+   
+};
+
+template<> struct pop_front< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pop_front< T1 > { }; }; template< typename Tag > struct lambda< pop_front< na > , Tag , int_<-1> > { typedef false_ is_le; typedef pop_front< na > result_; typedef pop_front< na > type; }; namespace aux { template< typename T1 > struct template_arity< pop_front< T1 > > : int_<1> { }; template<> struct template_arity< pop_front< na > > : int_<-1> { }; }
+
+}}
+# 26 "/usr/include/boost-1_42/boost/python/make_constructor.hpp" 2
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class T>
+  struct install_holder : converter::context_result_converter
+  {
+      install_holder(PyObject* args_)
+        : m_self(PyTuple_GetItem(args_, 0)) {}
+
+      PyObject* operator()(T x) const
+      {
+          dispatch(x, is_pointer<T>());
+          return none();
+      }
+
+   private:
+      template <class U>
+      void dispatch(U* x, mpl::true_) const
+      {
+          std::auto_ptr<U> owner(x);
+          dispatch(owner, mpl::false_());
+      }
+
+      template <class Ptr>
+      void dispatch(Ptr x, mpl::false_) const
+      {
+          typedef typename pointee<Ptr>::type value_type;
+          typedef objects::pointer_holder<Ptr,value_type> holder;
+          typedef objects::instance<holder> instance_t;
+
+          void* memory = holder::allocate(this->m_self, __builtin_offsetof (instance_t, storage), sizeof(holder));
+          try {
+              (new (memory) holder(x))->install(this->m_self);
+          }
+          catch(...) {
+              holder::deallocate(this->m_self, memory);
+              throw;
+          }
+      }
+
+      PyObject* m_self;
+  };
+
+  struct constructor_result_converter
+  {
+      template <class T>
+      struct apply
+      {
+          typedef install_holder<T> type;
+      };
+  };
+
+  template <class BaseArgs, class Offset>
+  struct offset_args
+  {
+      offset_args(BaseArgs base_) : base(base_) {}
+      BaseArgs base;
+  };
+
+  template <int N, class BaseArgs, class Offset>
+  inline PyObject* get(mpl::int_<N>, offset_args<BaseArgs,Offset> const& args_)
+  {
+      return get(mpl::int_<(N+Offset::value)>(), args_.base);
+  }
+
+  template <class BaseArgs, class Offset>
+  inline unsigned arity(offset_args<BaseArgs,Offset> const& args_)
+  {
+      return arity(args_.base) - Offset::value;
+  }
+
+  template <class BasePolicy_ = default_call_policies>
+  struct constructor_policy : BasePolicy_
+  {
+      constructor_policy(BasePolicy_ base) : BasePolicy_(base) {}
+# 115 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
+      struct MAKE_CONSTRUCTOR_SUPPLIES_ITS_OWN_RESULT_CONVERTER_THAT_WOULD_OVERRIDE_YOURS; typedef struct
+
+
+
+
+
+
+ MAKE_CONSTRUCTOR_SUPPLIES_ITS_OWN_RESULT_CONVERTER_THAT_WOULD_OVERRIDE_YOURS122
+# 115 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
+      : boost::mpl::assert_ { static boost::mpl::failed ************ (MAKE_CONSTRUCTOR_SUPPLIES_ITS_OWN_RESULT_CONVERTER_THAT_WOULD_OVERRIDE_YOURS::************ assert_arg()) (typename BasePolicy_::result_converter) { return 0; } }
+
+
+
+
+
+
+ mpl_assert_arg122
+# 115 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
+      ; enum { mpl_assertion_in_line_122 = sizeof( boost::mpl::assertion_failed<((is_same< typename BasePolicy_::result_converter , default_result_converter >::value))>( mpl_assert_arg122::assert_arg() ) ) }
+
+
+
+
+
+
+       ;
+
+      typedef constructor_result_converter result_converter;
+      typedef offset_args<typename BasePolicy_::argument_package, mpl::int_<1> > argument_package;
+  };
+
+  template <class InnerSignature>
+  struct outer_constructor_signature
+  {
+      typedef typename mpl::pop_front<InnerSignature>::type inner_args;
+      typedef typename mpl::push_front<inner_args,object>::type outer_args;
+      typedef typename mpl::push_front<outer_args,void>::type type;
+  };
+
+
+  template <>
+  struct outer_constructor_signature<int>
+  {
+      typedef int type;
+  };
+# 150 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
+  template <class F, class CallPolicies, class Sig>
+  object make_constructor_aux(
+      F f
+    , CallPolicies const& p
+    , Sig const&
+  )
+  {
+      typedef typename outer_constructor_signature<Sig>::type outer_signature;
+
+      typedef constructor_policy<CallPolicies> inner_policy;
+
+      return objects::function_object(
+          objects::py_function(
+              detail::caller<F,inner_policy,Sig>(f, inner_policy(p))
+            , outer_signature()
+          )
+      );
+  }
+
+
+
+
+
+  template <class F, class CallPolicies, class Sig, class NumKeywords>
+  object make_constructor_aux(
+      F f
+      , CallPolicies const& p
+      , Sig const&
+      , detail::keyword_range const& kw
+      , NumKeywords
+      )
+  {
+      enum { arity = mpl::size<Sig>::value - 1 };
+
+      typedef typename detail::error::more_keywords_than_function_arguments<
+          NumKeywords::value, arity
+          >::too_many_keywords assertion;
+
+      typedef typename outer_constructor_signature<Sig>::type outer_signature;
+
+      typedef constructor_policy<CallPolicies> inner_policy;
+
+      return objects::function_object(
+          objects::py_function(
+              detail::caller<F,inner_policy,Sig>(f, inner_policy(p))
+            , outer_signature()
+          )
+          , kw
+      );
+  }
+# 209 "/usr/include/boost-1_42/boost/python/make_constructor.hpp"
+  template <class F, class CallPolicies, class Keywords>
+  object make_constructor_dispatch(F f, CallPolicies const& policies, Keywords const& kw, mpl::true_)
+  {
+      return detail::make_constructor_aux(
+          f
+        , policies
+        , detail::get_signature(f)
+        , kw.range()
+        , mpl::int_<Keywords::size>()
+      );
+  }
+
+  template <class F, class CallPolicies, class Signature>
+  object make_constructor_dispatch(F f, CallPolicies const& policies, Signature const& sig, mpl::false_)
+  {
+      return detail::make_constructor_aux(
+          f
+        , policies
+        , sig
+      );
+  }
+
+}
+
+
+
+
+
+template <class F>
+object make_constructor(F f)
+{
+    return detail::make_constructor_aux(
+        f,default_call_policies(), detail::get_signature(f));
+}
+
+template <class F, class CallPolicies>
+object make_constructor(F f, CallPolicies const& policies)
+{
+    return detail::make_constructor_aux(
+        f, policies, detail::get_signature(f));
+}
+
+template <class F, class CallPolicies, class KeywordsOrSignature>
+object make_constructor(
+    F f
+  , CallPolicies const& policies
+  , KeywordsOrSignature const& keywords_or_signature)
+{
+    typedef typename
+        detail::is_reference_to_keywords<KeywordsOrSignature&>::type
+        is_kw;
+
+    return detail::make_constructor_dispatch(
+        f
+      , policies
+      , keywords_or_signature
+      , is_kw()
+    );
+}
+
+template <class F, class CallPolicies, class Keywords, class Signature>
+object make_constructor(
+    F f
+  , CallPolicies const& policies
+  , Keywords const& kw
+  , Signature const& sig
+ )
+{
+    return detail::make_constructor_aux(
+          f
+        , policies
+        , sig
+        , kw.range()
+        , mpl::int_<Keywords::size>()
+      );
+}
+
+
+}}
+# 42 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/manage_new_object.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/manage_new_object.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class R>
+  struct manage_new_object_requires_a_pointer_return_type
+
+  {}
+
+  ;
+}
+
+struct manage_new_object
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename mpl::if_c<
+            boost::is_pointer<T>::value
+            , to_python_indirect<T, detail::make_owning_holder>
+            , detail::manage_new_object_requires_a_pointer_return_type<T>
+        >::type type;
+    };
+};
+
+}}
+# 44 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/module.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/module.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/module_init.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/module_init.hpp"
+namespace boost { namespace python { namespace detail {
+
+ PyObject* init_module(char const* name, void(*)());
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/module.hpp" 2
+# 45 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/numeric.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/python/numeric.hpp"
+namespace boost { namespace python { namespace numeric {
+
+class array;
+
+namespace aux
+{
+  struct array_base : object
+  {
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        array_base( object const& x0);
+
+
+        array_base( object const& x0 , object const& x1);
+
+
+        array_base( object const& x0 , object const& x1 , object const& x2);
+
+
+        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3);
+
+
+        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3 , object const& x4);
+
+
+        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3 , object const& x4 , object const& x5);
+
+
+        array_base( object const& x0 , object const& x1 , object const& x2 , object const& x3 , object const& x4 , object const& x5 , object const& x6);
+# 30 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2
+
+      object argmax(long axis=-1);
+      object argmin(long axis=-1);
+      object argsort(long axis=-1);
+      object astype(object const& type = object());
+      void byteswap();
+      object copy() const;
+      object diagonal(long offset = 0, long axis1 = 0, long axis2 = 1) const;
+      void info() const;
+      bool is_c_array() const;
+      bool isbyteswapped() const;
+      array new_(object type) const;
+      void sort();
+      object trace(long offset = 0, long axis1 = 0, long axis2 = 1) const;
+      object type() const;
+      char typecode() const;
+
+      object factory(
+          object const& sequence = object()
+        , object const& typecode = object()
+        , bool copy = true
+        , bool savespace = false
+        , object type = object()
+        , object shape = object());
+
+      object getflat() const;
+      long getrank() const;
+      object getshape() const;
+      bool isaligned() const;
+      bool iscontiguous() const;
+      long itemsize() const;
+      long nelements() const;
+      object nonzero() const;
+
+      void put(object const& indices, object const& values);
+
+      void ravel();
+
+      object repeat(object const& repeats, long axis=0);
+
+      void resize(object const& shape);
+
+      void setflat(object const& flat);
+      void setshape(object const& shape);
+
+      void swapaxes(long axis1, long axis2);
+
+      object take(object const& sequence, long axis = 0) const;
+
+      void tofile(object const& file) const;
+
+      str tostring() const;
+
+      void transpose(object const& axes = object());
+
+      object view() const;
+
+   public:
+      inline explicit array_base(python::detail::borrowed_reference p) : object(p) {} inline explicit array_base(python::detail::new_reference p) : object(p) {} inline explicit array_base(python::detail::new_non_null_reference p) : object(p) {};
+  };
+
+  struct array_object_manager_traits
+  {
+      static bool check(PyObject* obj);
+      static detail::new_non_null_reference adopt(PyObject* obj);
+      static PyTypeObject const* get_pytype() ;
+  };
+}
+
+class array : public aux::array_base
+{
+    typedef aux::array_base base;
+ public:
+
+    object astype() { return base::astype(); }
+
+    template <class Type>
+    object astype(Type const& type_)
+    {
+        return base::astype(object(type_));
+    }
+
+    template <class Type>
+    array new_(Type const& type_) const
+    {
+        return base::new_(object(type_));
+    }
+
+    template <class Sequence>
+    void resize(Sequence const& x)
+    {
+        base::resize(object(x));
+    }
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        void resize( long x0) { resize(make_tuple( x0)); }
+
+
+        void resize( long x0 , long x1) { resize(make_tuple( x0 , x1)); }
+
+
+        void resize( long x0 , long x1 , long x2) { resize(make_tuple( x0 , x1 , x2)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3) { resize(make_tuple( x0 , x1 , x2 , x3)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4) { resize(make_tuple( x0 , x1 , x2 , x3 , x4)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13)); }
+
+
+        void resize( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13 , long x14) { resize(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13 , x14)); }
+# 131 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2
+
+    template <class Sequence>
+    void setshape(Sequence const& x)
+    {
+        base::setshape(object(x));
+    }
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        void setshape( long x0) { setshape(make_tuple( x0)); }
+
+
+        void setshape( long x0 , long x1) { setshape(make_tuple( x0 , x1)); }
+
+
+        void setshape( long x0 , long x1 , long x2) { setshape(make_tuple( x0 , x1 , x2)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3) { setshape(make_tuple( x0 , x1 , x2 , x3)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13)); }
+
+
+        void setshape( long x0 , long x1 , long x2 , long x3 , long x4 , long x5 , long x6 , long x7 , long x8 , long x9 , long x10 , long x11 , long x12 , long x13 , long x14) { setshape(make_tuple( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 , x10 , x11 , x12 , x13 , x14)); }
+# 145 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2
+
+    template <class Indices, class Values>
+    void put(Indices const& indices, Values const& values)
+    {
+        base::put(object(indices), object(values));
+    }
+
+    template <class Sequence>
+    object take(Sequence const& sequence, long axis = 0)
+    {
+        return base::take(object(sequence), axis);
+    }
+
+    template <class File>
+    void tofile(File const& f) const
+    {
+        base::tofile(object(f));
+    }
+
+    object factory()
+    {
+        return base::factory();
+    }
+
+    template <class Sequence>
+    object factory(Sequence const& sequence)
+    {
+        return base::factory(object(sequence));
+    }
+
+    template <class Sequence, class Typecode>
+    object factory(
+        Sequence const& sequence
+      , Typecode const& typecode_
+      , bool copy = true
+      , bool savespace = false
+    )
+    {
+        return base::factory(object(sequence), object(typecode_), copy, savespace);
+    }
+
+    template <class Sequence, class Typecode, class Type>
+    object factory(
+        Sequence const& sequence
+      , Typecode const& typecode_
+      , bool copy
+      , bool savespace
+      , Type const& type
+    )
+    {
+        return base::factory(object(sequence), object(typecode_), copy, savespace, object(type));
+    }
+
+    template <class Sequence, class Typecode, class Type, class Shape>
+    object factory(
+        Sequence const& sequence
+      , Typecode const& typecode_
+      , bool copy
+      , bool savespace
+      , Type const& type
+      , Shape const& shape
+    )
+    {
+        return base::factory(object(sequence), object(typecode_), copy, savespace, object(type), object(shape));
+    }
+# 218 "/usr/include/boost-1_42/boost/python/numeric.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        template < class T0> explicit array( T0 const& x0) : base( object(x0)) {}
+
+
+        template < class T0 , class T1> explicit array( T0 const& x0 , T1 const& x1) : base( object(x0) , object(x1)) {}
+
+
+        template < class T0 , class T1 , class T2> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2) : base( object(x0) , object(x1) , object(x2)) {}
+
+
+        template < class T0 , class T1 , class T2 , class T3> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3) : base( object(x0) , object(x1) , object(x2) , object(x3)) {}
+
+
+        template < class T0 , class T1 , class T2 , class T3 , class T4> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3 , T4 const& x4) : base( object(x0) , object(x1) , object(x2) , object(x3) , object(x4)) {}
+
+
+        template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3 , T4 const& x4 , T5 const& x5) : base( object(x0) , object(x1) , object(x2) , object(x3) , object(x4) , object(x5)) {}
+
+
+        template < class T0 , class T1 , class T2 , class T3 , class T4 , class T5 , class T6> explicit array( T0 const& x0 , T1 const& x1 , T2 const& x2 , T3 const& x3 , T4 const& x4 , T5 const& x5 , T6 const& x6) : base( object(x0) , object(x1) , object(x2) , object(x3) , object(x4) , object(x5) , object(x6)) {}
+# 219 "/usr/include/boost-1_42/boost/python/numeric.hpp" 2
+
+
+    static void set_module_and_type(char const* package_name = 0, char const* type_attribute_name = 0);
+    static std::string get_module_name();
+
+ public:
+    inline explicit array(python::detail::borrowed_reference p) : base(p) {} inline explicit array(python::detail::new_reference p) : base(p) {} inline explicit array(python::detail::new_non_null_reference p) : base(p) {};
+};
+
+}
+
+namespace converter
+{
+  template <>
+  struct object_manager_traits< numeric::array >
+      : numeric::aux::array_object_manager_traits
+  {
+      static const bool is_specialized = true;
+  };
+}
+
+}}
+# 46 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/dealloc.hpp" 1
+
+
+
+
+
+
+
+namespace boost { namespace python { namespace detail {
+    extern "C"
+    {
+        inline void dealloc(PyObject* self)
+        {
+          PyObject_Free(self);
+        }
+    }
+}}}
+# 16 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp" 2
+# 41 "/usr/include/boost-1_42/boost/python/opaque_pointer_converter.hpp"
+namespace boost { namespace python {
+
+template <class Pointee>
+struct opaque
+{
+    opaque()
+    {
+        if (type_object.tp_name == 0)
+        {
+            type_object.tp_name = const_cast<char*>(type_id<Pointee*>().name());
+            if (PyType_Ready (&type_object) < 0)
+            {
+                throw error_already_set();
+            }
+
+            this->register_self();
+        }
+    }
+
+    static opaque instance;
+private:
+
+    static void* extract(PyObject* op)
+    {
+        return ((((PyObject*)(op))->ob_type) == (&type_object) || PyType_IsSubtype((((PyObject*)(op))->ob_type), (&type_object)))
+            ? static_cast<python_instance*>(implicit_cast<void*>(op))->x
+            : 0
+            ;
+    }
+
+    static PyObject* wrap(void const* px)
+    {
+        Pointee* x = *static_cast<Pointee*const*>(px);
+
+        if (x == 0)
+            return detail::none();
+
+        if ( python_instance *o = ( (python_instance *) _PyObject_New(&type_object) ) )
+        {
+            o->x = x;
+            return static_cast<PyObject*>(implicit_cast<void*>(o));
+        }
+        else
+        {
+            throw error_already_set();
+        }
+    }
+
+    void register_self()
+    {
+        converter::registration const *existing =
+            converter::registry::query (type_id<Pointee*>());
+
+        if ((existing == 0) || (existing->m_to_python == 0))
+        {
+
+            converter::registry::insert(&extract, type_id<Pointee>(), &get_pytype);
+            converter::registry::insert(&wrap, type_id<Pointee*>(), &get_pytype);
+
+
+
+
+        }
+    }
+
+    struct python_instance
+    {
+        Py_ssize_t ob_refcnt; struct _typeobject *ob_type;
+        Pointee* x;
+    };
+
+    static PyTypeObject type_object;
+
+    static PyTypeObject const *get_pytype(){return &type_object; }
+
+};
+
+template <class Pointee>
+opaque<Pointee> opaque<Pointee>::instance;
+
+template <class Pointee>
+PyTypeObject opaque<Pointee>::type_object =
+{
+    1, __null, 0,
+    0,
+    sizeof( typename opaque<Pointee>::python_instance ),
+    0,
+    ::boost::python::detail::dealloc,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+
+    0
+
+};
+}}
+# 50 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/operators.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/python/operators.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/self.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/self.hpp"
+namespace boost { namespace python {
+
+
+
+
+
+
+
+namespace self_ns
+{
+
+
+
+  struct self_t {};
+  extern self_t self;
+
+}
+
+using self_ns::self_t;
+using self_ns::self;
+
+}}
+# 18 "/usr/include/boost-1_42/boost/python/operators.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/other.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/other.hpp"
+namespace boost { namespace python {
+
+template<class T> struct other
+{
+    typedef T type;
+};
+
+
+namespace detail
+{
+  template<typename T>
+  class is_other
+  {
+   public:
+      static const bool value = false;
+  };
+
+  template<typename T>
+  class is_other<other<T> >
+  {
+   public:
+      static const bool value = true;
+  };
+
+  template<typename T>
+  class unwrap_other
+  {
+   public:
+      typedef T type;
+  };
+
+  template<typename T>
+  class unwrap_other<other<T> >
+  {
+   public:
+      typedef T type;
+  };
+}
+# 112 "/usr/include/boost-1_42/boost/python/other.hpp"
+}}
+# 19 "/usr/include/boost-1_42/boost/python/operators.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 2 3
+# 18 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 19 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp" 2
+
+namespace boost {
+
+
+
+namespace detail{
+
+
+
+template <class T>
+struct is_signed_values
+{
+   typedef typename remove_cv<T>::type no_cv_t;
+   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+   static const no_cv_t zero = (static_cast<no_cv_t>(0));
+};
+
+template <class T>
+struct is_signed_helper
+{
+   typedef typename remove_cv<T>::type no_cv_t;
+   static const bool value = (!(::boost::detail::is_signed_values<T>::minus_one > boost::detail::is_signed_values<T>::zero));
+};
+
+template <bool integral_type>
+struct is_signed_select_helper
+{
+   template <class T>
+   struct rebind
+   {
+      typedef is_signed_helper<T> type;
+   };
+};
+
+template <>
+struct is_signed_select_helper<false>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <class T>
+struct is_signed_imp
+{
+   typedef is_signed_select_helper<
+      ::boost::type_traits::ice_or<
+         ::boost::is_integral<T>::value,
+         ::boost::is_enum<T>::value>::value
+   > selector;
+   typedef typename selector::template rebind<T> binder;
+   typedef typename binder::type type;
+
+
+
+   static const bool value = type::value;
+
+};
+# 121 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp"
+}
+
+
+
+
+
+
+template< typename T > struct is_signed : ::boost::integral_constant<bool,::boost::detail::is_signed_imp<T>::value> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 134 "/usr/include/boost-1_42/boost/type_traits/is_signed.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp" 2
+
+namespace boost {
+
+
+
+namespace detail{
+
+
+
+template <class T>
+struct is_unsigned_values
+{
+   typedef typename remove_cv<T>::type no_cv_t;
+   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
+   static const no_cv_t zero = (static_cast<no_cv_t>(0));
+};
+
+template <class T>
+struct is_ununsigned_helper
+{
+   static const bool value = (::boost::detail::is_unsigned_values<T>::minus_one > ::boost::detail::is_unsigned_values<T>::zero);
+};
+
+template <bool integral_type>
+struct is_ununsigned_select_helper
+{
+   template <class T>
+   struct rebind
+   {
+      typedef is_ununsigned_helper<T> type;
+   };
+};
+
+template <>
+struct is_ununsigned_select_helper<false>
+{
+   template <class T>
+   struct rebind
+   {
+      typedef false_type type;
+   };
+};
+
+template <class T>
+struct is_unsigned_imp
+{
+   typedef is_ununsigned_select_helper<
+      ::boost::type_traits::ice_or<
+         ::boost::is_integral<T>::value,
+         ::boost::is_enum<T>::value>::value
+   > selector;
+   typedef typename selector::template rebind<T> binder;
+   typedef typename binder::type type;
+   static const bool value = type::value;
+};
+# 116 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp"
+}
+
+
+
+
+
+
+template< typename T > struct is_unsigned : ::boost::integral_constant<bool,::boost::detail::is_unsigned_imp<T>::value> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 129 "/usr/include/boost-1_42/boost/type_traits/is_unsigned.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <class T>
+struct make_unsigned_imp
+{
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_39;
+
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)>
+
+ boost_static_assert_typedef_43;
+
+
+   typedef typename remove_cv<T>::type t_no_cv;
+   typedef typename mpl::if_c<
+      (::boost::type_traits::ice_and<
+         ::boost::is_unsigned<T>::value,
+         ::boost::is_integral<T>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
+      T,
+      typename mpl::if_c<
+         (::boost::type_traits::ice_and<
+            ::boost::is_integral<T>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
+         ::value),
+         typename mpl::if_<
+            is_same<t_no_cv, signed char>,
+            unsigned char,
+            typename mpl::if_<
+               is_same<t_no_cv, short>,
+               unsigned short,
+               typename mpl::if_<
+                  is_same<t_no_cv, int>,
+                  unsigned int,
+                  typename mpl::if_<
+                     is_same<t_no_cv, long>,
+                     unsigned long,
+
+                     boost::ulong_long_type
+
+
+
+
+
+                  >::type
+               >::type
+            >::type
+         >::type,
+
+         typename mpl::if_c<
+            sizeof(t_no_cv) == sizeof(unsigned char),
+            unsigned char,
+            typename mpl::if_c<
+               sizeof(t_no_cv) == sizeof(unsigned short),
+               unsigned short,
+               typename mpl::if_c<
+                  sizeof(t_no_cv) == sizeof(unsigned int),
+                  unsigned int,
+                  typename mpl::if_c<
+                     sizeof(t_no_cv) == sizeof(unsigned long),
+                     unsigned long,
+
+                     boost::ulong_long_type
+
+
+
+
+
+                  >::type
+               >::type
+            >::type
+         >::type
+      >::type
+   >::type base_integer_type;
+
+
+   typedef typename mpl::if_<
+      is_const<T>,
+      typename add_const<base_integer_type>::type,
+      base_integer_type
+   >::type const_base_integer_type;
+
+
+   typedef typename mpl::if_<
+      is_volatile<T>,
+      typename add_volatile<const_base_integer_type>::type,
+      const_base_integer_type
+   >::type type;
+};
+
+
+}
+
+template< typename T > struct make_unsigned { typedef typename boost::detail::make_unsigned_imp<T>::type type; };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 135 "/usr/include/boost-1_42/boost/type_traits/make_unsigned.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/climits" 2 3
+# 12 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp"
+namespace boost { namespace detail {
+
+class lcast_abstract_stub {};
+
+
+
+
+
+template<class T>
+struct lcast_precision
+{
+
+
+
+    typedef typename boost::mpl::if_<
+        boost::is_abstract<T>
+      , std::numeric_limits<lcast_abstract_stub>
+      , std::numeric_limits<T>
+      >::type limits;
+
+
+    static const bool use_default_precision = !limits::is_specialized || limits::is_exact
+
+         ;
+
+    static const bool is_specialized_bin = !use_default_precision && limits::radix == 2 && limits::digits > 0
+
+
+         ;
+
+    static const bool is_specialized_dec = !use_default_precision && limits::radix == 10 && limits::digits10 > 0
+
+
+         ;
+
+    static const std::streamsize streamsize_max = boost::integer_traits<std::streamsize>::const_max
+
+         ;
+
+    static const unsigned int precision_dec = limits::digits10 + 1U;
+
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!is_specialized_dec || precision_dec <= streamsize_max + 0UL) == 0 ? false : true) >)>
+
+ boost_static_assert_typedef_79;
+
+    static const unsigned long precision_bin = 2UL + limits::digits * 30103UL / 100000UL
+
+         ;
+
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!is_specialized_bin || (limits::digits + 0UL < (9223372036854775807L * 2UL + 1UL) / 30103UL && precision_bin > limits::digits10 + 0UL && precision_bin <= streamsize_max + 0UL)) == 0 ? false : true) >)>
+
+
+
+ boost_static_assert_typedef_89;
+
+    static const std::streamsize value = is_specialized_bin ? precision_bin : is_specialized_dec ? precision_dec : 6
+
+
+         ;
+};
+
+
+template<class T>
+inline std::streamsize lcast_get_precision(T* = 0)
+{
+
+    return lcast_precision<T>::value;
+# 165 "/usr/include/boost-1_42/boost/detail/lcast_precision.hpp"
+}
+
+template<class T>
+inline void lcast_set_precision(std::ios_base& stream, T*)
+{
+    stream.precision(lcast_get_precision<T>());
+}
+
+template<class Source, class Target>
+inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
+{
+    std::streamsize const s = lcast_get_precision((Source*)0);
+    std::streamsize const t = lcast_get_precision((Target*)0);
+    stream.precision(s > t ? s : t);
+}
+
+}}
+# 32 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 3
+       
+# 39 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 3
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+       
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 2 3
+# 60 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/ctime" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  using ::clock_t;
+  using ::time_t;
+  using ::tm;
+
+  using ::clock;
+  using ::difftime;
+  using ::mktime;
+  using ::time;
+  using ::asctime;
+  using ::ctime;
+  using ::gmtime;
+  using ::localtime;
+  using ::strftime;
+
+}
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 50 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  class time_base
+  {
+  public:
+    enum dateorder { no_order, dmy, mdy, ymd, ydm };
+  };
+
+  template<typename _CharT>
+    struct __timepunct_cache : public locale::facet
+    {
+
+      static const _CharT* _S_timezones[14];
+
+      const _CharT* _M_date_format;
+      const _CharT* _M_date_era_format;
+      const _CharT* _M_time_format;
+      const _CharT* _M_time_era_format;
+      const _CharT* _M_date_time_format;
+      const _CharT* _M_date_time_era_format;
+      const _CharT* _M_am;
+      const _CharT* _M_pm;
+      const _CharT* _M_am_pm_format;
+
+
+      const _CharT* _M_day1;
+      const _CharT* _M_day2;
+      const _CharT* _M_day3;
+      const _CharT* _M_day4;
+      const _CharT* _M_day5;
+      const _CharT* _M_day6;
+      const _CharT* _M_day7;
+
+
+      const _CharT* _M_aday1;
+      const _CharT* _M_aday2;
+      const _CharT* _M_aday3;
+      const _CharT* _M_aday4;
+      const _CharT* _M_aday5;
+      const _CharT* _M_aday6;
+      const _CharT* _M_aday7;
+
+
+      const _CharT* _M_month01;
+      const _CharT* _M_month02;
+      const _CharT* _M_month03;
+      const _CharT* _M_month04;
+      const _CharT* _M_month05;
+      const _CharT* _M_month06;
+      const _CharT* _M_month07;
+      const _CharT* _M_month08;
+      const _CharT* _M_month09;
+      const _CharT* _M_month10;
+      const _CharT* _M_month11;
+      const _CharT* _M_month12;
+
+
+      const _CharT* _M_amonth01;
+      const _CharT* _M_amonth02;
+      const _CharT* _M_amonth03;
+      const _CharT* _M_amonth04;
+      const _CharT* _M_amonth05;
+      const _CharT* _M_amonth06;
+      const _CharT* _M_amonth07;
+      const _CharT* _M_amonth08;
+      const _CharT* _M_amonth09;
+      const _CharT* _M_amonth10;
+      const _CharT* _M_amonth11;
+      const _CharT* _M_amonth12;
+
+      bool _M_allocated;
+
+      __timepunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_date_format(__null), _M_date_era_format(__null), _M_time_format(__null),
+      _M_time_era_format(__null), _M_date_time_format(__null),
+      _M_date_time_era_format(__null), _M_am(__null), _M_pm(__null),
+      _M_am_pm_format(__null), _M_day1(__null), _M_day2(__null), _M_day3(__null),
+      _M_day4(__null), _M_day5(__null), _M_day6(__null), _M_day7(__null),
+      _M_aday1(__null), _M_aday2(__null), _M_aday3(__null), _M_aday4(__null),
+      _M_aday5(__null), _M_aday6(__null), _M_aday7(__null), _M_month01(__null),
+      _M_month02(__null), _M_month03(__null), _M_month04(__null), _M_month05(__null),
+      _M_month06(__null), _M_month07(__null), _M_month08(__null), _M_month09(__null),
+      _M_month10(__null), _M_month11(__null), _M_month12(__null), _M_amonth01(__null),
+      _M_amonth02(__null), _M_amonth03(__null), _M_amonth04(__null),
+      _M_amonth05(__null), _M_amonth06(__null), _M_amonth07(__null),
+      _M_amonth08(__null), _M_amonth09(__null), _M_amonth10(__null),
+      _M_amonth11(__null), _M_amonth12(__null), _M_allocated(false)
+      { }
+
+      ~__timepunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __timepunct_cache&
+      operator=(const __timepunct_cache&);
+
+      explicit
+      __timepunct_cache(const __timepunct_cache&);
+    };
+
+  template<typename _CharT>
+    __timepunct_cache<_CharT>::~__timepunct_cache()
+    {
+      if (_M_allocated)
+ {
+
+ }
+    }
+
+
+  template<>
+    const char*
+    __timepunct_cache<char>::_S_timezones[14];
+
+
+  template<>
+    const wchar_t*
+    __timepunct_cache<wchar_t>::_S_timezones[14];
+
+
+
+  template<typename _CharT>
+    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];
+
+  template<typename _CharT>
+    class __timepunct : public locale::facet
+    {
+    public:
+
+      typedef _CharT __char_type;
+      typedef basic_string<_CharT> __string_type;
+      typedef __timepunct_cache<_CharT> __cache_type;
+
+    protected:
+      __cache_type* _M_data;
+      __c_locale _M_c_locale_timepunct;
+      const char* _M_name_timepunct;
+
+    public:
+
+      static locale::id id;
+
+      explicit
+      __timepunct(size_t __refs = 0);
+
+      explicit
+      __timepunct(__cache_type* __cache, size_t __refs = 0);
+# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);
+
+
+
+      void
+      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
+      const tm* __tm) const throw ();
+
+      void
+      _M_date_formats(const _CharT** __date) const
+      {
+
+ __date[0] = _M_data->_M_date_format;
+ __date[1] = _M_data->_M_date_era_format;
+      }
+
+      void
+      _M_time_formats(const _CharT** __time) const
+      {
+
+ __time[0] = _M_data->_M_time_format;
+ __time[1] = _M_data->_M_time_era_format;
+      }
+
+      void
+      _M_date_time_formats(const _CharT** __dt) const
+      {
+
+ __dt[0] = _M_data->_M_date_time_format;
+ __dt[1] = _M_data->_M_date_time_era_format;
+      }
+
+      void
+      _M_am_pm_format(const _CharT* __ampm) const
+      { __ampm = _M_data->_M_am_pm_format; }
+
+      void
+      _M_am_pm(const _CharT** __ampm) const
+      {
+ __ampm[0] = _M_data->_M_am;
+ __ampm[1] = _M_data->_M_pm;
+      }
+
+      void
+      _M_days(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_day1;
+ __days[1] = _M_data->_M_day2;
+ __days[2] = _M_data->_M_day3;
+ __days[3] = _M_data->_M_day4;
+ __days[4] = _M_data->_M_day5;
+ __days[5] = _M_data->_M_day6;
+ __days[6] = _M_data->_M_day7;
+      }
+
+      void
+      _M_days_abbreviated(const _CharT** __days) const
+      {
+ __days[0] = _M_data->_M_aday1;
+ __days[1] = _M_data->_M_aday2;
+ __days[2] = _M_data->_M_aday3;
+ __days[3] = _M_data->_M_aday4;
+ __days[4] = _M_data->_M_aday5;
+ __days[5] = _M_data->_M_aday6;
+ __days[6] = _M_data->_M_aday7;
+      }
+
+      void
+      _M_months(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_month01;
+ __months[1] = _M_data->_M_month02;
+ __months[2] = _M_data->_M_month03;
+ __months[3] = _M_data->_M_month04;
+ __months[4] = _M_data->_M_month05;
+ __months[5] = _M_data->_M_month06;
+ __months[6] = _M_data->_M_month07;
+ __months[7] = _M_data->_M_month08;
+ __months[8] = _M_data->_M_month09;
+ __months[9] = _M_data->_M_month10;
+ __months[10] = _M_data->_M_month11;
+ __months[11] = _M_data->_M_month12;
+      }
+
+      void
+      _M_months_abbreviated(const _CharT** __months) const
+      {
+ __months[0] = _M_data->_M_amonth01;
+ __months[1] = _M_data->_M_amonth02;
+ __months[2] = _M_data->_M_amonth03;
+ __months[3] = _M_data->_M_amonth04;
+ __months[4] = _M_data->_M_amonth05;
+ __months[5] = _M_data->_M_amonth06;
+ __months[6] = _M_data->_M_amonth07;
+ __months[7] = _M_data->_M_amonth08;
+ __months[8] = _M_data->_M_amonth09;
+ __months[9] = _M_data->_M_amonth10;
+ __months[10] = _M_data->_M_amonth11;
+ __months[11] = _M_data->_M_amonth12;
+      }
+
+    protected:
+      virtual
+      ~__timepunct();
+
+
+      void
+      _M_initialize_timepunct(__c_locale __cloc = __null);
+    };
+
+  template<typename _CharT>
+    locale::id __timepunct<_CharT>::id;
+
+
+  template<>
+    void
+    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();
+
+
+  template<>
+    void
+    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);
+
+  template<>
+    void
+    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
+     const tm*) const throw ();
+
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/time_members.h" 1 3
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/time_members.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(size_t __refs)
+    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
+    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(__null),
+      _M_name_timepunct(_S_get_c_name())
+    { _M_initialize_timepunct(); }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
+         size_t __refs)
+    : facet(__refs), _M_data(__null), _M_c_locale_timepunct(__null),
+      _M_name_timepunct(__null)
+    {
+      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+ {
+   const size_t __len = __builtin_strlen(__s) + 1;
+   char* __tmp = new char[__len];
+   __builtin_memcpy(__tmp, __s, __len);
+   _M_name_timepunct = __tmp;
+ }
+      else
+ _M_name_timepunct = _S_get_c_name();
+
+      try
+ { _M_initialize_timepunct(__cloc); }
+      catch(...)
+ {
+   if (_M_name_timepunct != _S_get_c_name())
+     delete [] _M_name_timepunct;
+   throw;
+ }
+    }
+
+  template<typename _CharT>
+    __timepunct<_CharT>::~__timepunct()
+    {
+      if (_M_name_timepunct != _S_get_c_name())
+ delete [] _M_name_timepunct;
+      delete _M_data;
+      _S_destroy_c_locale(_M_c_locale_timepunct);
+    }
+
+}
+# 346 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 362 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _InIter>
+    class time_get : public locale::facet, public time_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+      typedef basic_string<_CharT> __string_type;
+
+
+      static locale::id id;
+# 384 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      time_get(size_t __refs = 0)
+      : facet (__refs) { }
+# 401 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      dateorder
+      date_order() const
+      { return this->do_date_order(); }
+# 425 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_time(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
+# 450 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_date(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
+# 478 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
+# 507 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
+      ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
+# 533 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      get_year(iter_type __beg, iter_type __end, ios_base& __io,
+        ios_base::iostate& __err, tm* __tm) const
+      { return this->do_get_year(__beg, __end, __io, __err, __tm); }
+
+    protected:
+
+      virtual
+      ~time_get() { }
+# 553 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual dateorder
+      do_date_order() const;
+# 571 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 590 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+# 609 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
+       ios_base::iostate& __err, tm* __tm) const;
+# 628 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
+         ios_base::iostate& __err, tm* __tm) const;
+# 647 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+    ios_base::iostate& __err, tm* __tm) const;
+
+
+      iter_type
+      _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+       int __min, int __max, size_t __len,
+       ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+          const _CharT** __names, size_t __indexlen,
+          ios_base& __io, ios_base::iostate& __err) const;
+
+
+      iter_type
+      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+       ios_base::iostate& __err, tm* __tm,
+       const _CharT* __format) const;
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id time_get<_CharT, _InIter>::id;
+
+
+  template<typename _CharT, typename _InIter>
+    class time_get_byname : public time_get<_CharT, _InIter>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+
+      explicit
+      time_get_byname(const char*, size_t __refs = 0)
+      : time_get<_CharT, _InIter>(__refs) { }
+
+    protected:
+      virtual
+      ~time_get_byname() { }
+    };
+# 709 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _OutIter>
+    class time_put : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+
+
+      static locale::id id;
+# 730 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      time_put(size_t __refs = 0)
+      : facet(__refs) { }
+# 749 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+   const _CharT* __beg, const _CharT* __end) const;
+# 769 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, ios_base& __io, char_type __fill,
+   const tm* __tm, char __format, char __mod = 0) const
+      { return this->do_put(__s, __io, __fill, __tm, __format, __mod); }
+
+    protected:
+
+      virtual
+      ~time_put()
+      { }
+# 796 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+      char __format, char __mod) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id time_put<_CharT, _OutIter>::id;
+
+
+  template<typename _CharT, typename _OutIter>
+    class time_put_byname : public time_put<_CharT, _OutIter>
+    {
+    public:
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+
+      explicit
+      time_put_byname(const char*, size_t __refs = 0)
+      : time_put<_CharT, _OutIter>(__refs)
+      { };
+
+    protected:
+      virtual
+      ~time_put_byname() { }
+    };
+# 835 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  class money_base
+  {
+  public:
+    enum part { none, space, symbol, sign, value };
+    struct pattern { char field[4]; };
+
+    static const pattern _S_default_pattern;
+
+    enum
+    {
+      _S_minus,
+      _S_zero,
+      _S_end = 11
+    };
+
+
+
+    static const char* _S_atoms;
+
+
+
+    __attribute__ ((__const__)) static pattern
+    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
+  };
+
+  template<typename _CharT, bool _Intl>
+    struct __moneypunct_cache : public locale::facet
+    {
+      const char* _M_grouping;
+      size_t _M_grouping_size;
+      bool _M_use_grouping;
+      _CharT _M_decimal_point;
+      _CharT _M_thousands_sep;
+      const _CharT* _M_curr_symbol;
+      size_t _M_curr_symbol_size;
+      const _CharT* _M_positive_sign;
+      size_t _M_positive_sign_size;
+      const _CharT* _M_negative_sign;
+      size_t _M_negative_sign_size;
+      int _M_frac_digits;
+      money_base::pattern _M_pos_format;
+      money_base::pattern _M_neg_format;
+
+
+
+
+      _CharT _M_atoms[money_base::_S_end];
+
+      bool _M_allocated;
+
+      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
+      _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false),
+      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
+      _M_curr_symbol(__null), _M_curr_symbol_size(0),
+      _M_positive_sign(__null), _M_positive_sign_size(0),
+      _M_negative_sign(__null), _M_negative_sign_size(0),
+      _M_frac_digits(0),
+      _M_pos_format(money_base::pattern()),
+      _M_neg_format(money_base::pattern()), _M_allocated(false)
+      { }
+
+      ~__moneypunct_cache();
+
+      void
+      _M_cache(const locale& __loc);
+
+    private:
+      __moneypunct_cache&
+      operator=(const __moneypunct_cache&);
+
+      explicit
+      __moneypunct_cache(const __moneypunct_cache&);
+    };
+
+  template<typename _CharT, bool _Intl>
+    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
+    {
+      if (_M_allocated)
+ {
+   delete [] _M_grouping;
+   delete [] _M_curr_symbol;
+   delete [] _M_positive_sign;
+   delete [] _M_negative_sign;
+ }
+    }
+# 928 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, bool _Intl>
+    class moneypunct : public locale::facet, public money_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+    private:
+      __cache_type* _M_data;
+
+    public:
+
+
+      static const bool intl = _Intl;
+
+      static locale::id id;
+# 957 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(size_t __refs = 0) : facet(__refs), _M_data(__null)
+      { _M_initialize_moneypunct(); }
+# 969 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(__cache_type* __cache, size_t __refs = 0)
+      : facet(__refs), _M_data(__cache)
+      { _M_initialize_moneypunct(); }
+# 984 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
+      : facet(__refs), _M_data(__null)
+      { _M_initialize_moneypunct(__cloc, __s); }
+# 998 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      char_type
+      decimal_point() const
+      { return this->do_decimal_point(); }
+# 1011 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      char_type
+      thousands_sep() const
+      { return this->do_thousands_sep(); }
+# 1041 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      string
+      grouping() const
+      { return this->do_grouping(); }
+# 1054 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      string_type
+      curr_symbol() const
+      { return this->do_curr_symbol(); }
+# 1071 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      string_type
+      positive_sign() const
+      { return this->do_positive_sign(); }
+# 1088 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      string_type
+      negative_sign() const
+      { return this->do_negative_sign(); }
+# 1104 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      int
+      frac_digits() const
+      { return this->do_frac_digits(); }
+# 1140 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      pattern
+      pos_format() const
+      { return this->do_pos_format(); }
+
+      pattern
+      neg_format() const
+      { return this->do_neg_format(); }
+
+
+    protected:
+
+      virtual
+      ~moneypunct();
+# 1162 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual char_type
+      do_decimal_point() const
+      { return _M_data->_M_decimal_point; }
+# 1174 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual char_type
+      do_thousands_sep() const
+      { return _M_data->_M_thousands_sep; }
+# 1187 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual string
+      do_grouping() const
+      { return _M_data->_M_grouping; }
+# 1200 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_curr_symbol() const
+      { return _M_data->_M_curr_symbol; }
+# 1213 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_positive_sign() const
+      { return _M_data->_M_positive_sign; }
+# 1226 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_negative_sign() const
+      { return _M_data->_M_negative_sign; }
+# 1240 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual int
+      do_frac_digits() const
+      { return _M_data->_M_frac_digits; }
+# 1254 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual pattern
+      do_pos_format() const
+      { return _M_data->_M_pos_format; }
+# 1268 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual pattern
+      do_neg_format() const
+      { return _M_data->_M_neg_format; }
+
+
+       void
+       _M_initialize_moneypunct(__c_locale __cloc = __null,
+    const char* __name = __null);
+    };
+
+  template<typename _CharT, bool _Intl>
+    locale::id moneypunct<_CharT, _Intl>::id;
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct<_CharT, _Intl>::intl;
+
+  template<>
+    moneypunct<char, true>::~moneypunct();
+
+  template<>
+    moneypunct<char, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);
+
+  template<>
+    void
+    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);
+
+
+  template<>
+    moneypunct<wchar_t, true>::~moneypunct();
+
+  template<>
+    moneypunct<wchar_t, false>::~moneypunct();
+
+  template<>
+    void
+    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
+       const char*);
+
+  template<>
+    void
+    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
+        const char*);
+
+
+
+  template<typename _CharT, bool _Intl>
+    class moneypunct_byname : public moneypunct<_CharT, _Intl>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      static const bool intl = _Intl;
+
+      explicit
+      moneypunct_byname(const char* __s, size_t __refs = 0)
+      : moneypunct<_CharT, _Intl>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     __c_locale __tmp;
+     this->_S_create_c_locale(__tmp, __s);
+     this->_M_initialize_moneypunct(__tmp);
+     this->_S_destroy_c_locale(__tmp);
+   }
+      }
+
+    protected:
+      virtual
+      ~moneypunct_byname() { }
+    };
+
+  template<typename _CharT, bool _Intl>
+    const bool moneypunct_byname<_CharT, _Intl>::intl;
+
+
+# 1363 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _InIter>
+    class money_get : public locale::facet
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef _InIter iter_type;
+      typedef basic_string<_CharT> string_type;
+
+
+
+      static locale::id id;
+# 1385 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      money_get(size_t __refs = 0) : facet(__refs) { }
+# 1415 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, long double& __units) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
+# 1446 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+   ios_base::iostate& __err, string_type& __digits) const
+      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }
+
+    protected:
+
+      virtual
+      ~money_get() { }
+# 1469 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, long double& __units) const;
+# 1481 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
+      ios_base::iostate& __err, string_type& __digits) const;
+# 1492 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      template<bool _Intl>
+        iter_type
+        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, string& __digits) const;
+    };
+
+  template<typename _CharT, typename _InIter>
+    locale::id money_get<_CharT, _InIter>::id;
+# 1514 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  template<typename _CharT, typename _OutIter>
+    class money_put : public locale::facet
+    {
+    public:
+
+
+      typedef _CharT char_type;
+      typedef _OutIter iter_type;
+      typedef basic_string<_CharT> string_type;
+
+
+
+      static locale::id id;
+# 1535 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      money_put(size_t __refs = 0) : facet(__refs) { }
+# 1555 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, long double __units) const
+      { return this->do_put(__s, __intl, __io, __fill, __units); }
+# 1578 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      iter_type
+      put(iter_type __s, bool __intl, ios_base& __io,
+   char_type __fill, const string_type& __digits) const
+      { return this->do_put(__s, __intl, __io, __fill, __digits); }
+
+    protected:
+
+      virtual
+      ~money_put() { }
+# 1612 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      long double __units) const;
+# 1636 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual iter_type
+      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+      const string_type& __digits) const;
+# 1647 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      template<bool _Intl>
+        iter_type
+        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+    const string_type& __digits) const;
+    };
+
+  template<typename _CharT, typename _OutIter>
+    locale::id money_put<_CharT, _OutIter>::id;
+
+
+
+
+
+
+
+  struct messages_base
+  {
+    typedef int catalog;
+  };
+# 1688 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+  template<typename _CharT>
+    class messages : public locale::facet, public messages_base
+    {
+    public:
+
+
+
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+
+    protected:
+
+
+      __c_locale _M_c_locale_messages;
+      const char* _M_name_messages;
+
+    public:
+
+      static locale::id id;
+# 1716 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      messages(size_t __refs = 0);
+# 1730 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      explicit
+      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
+# 1743 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      catalog
+      open(const basic_string<char>& __s, const locale& __loc) const
+      { return this->do_open(__s, __loc); }
+# 1761 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      catalog
+      open(const basic_string<char>&, const locale&, const char*) const;
+# 1779 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      string_type
+      get(catalog __c, int __set, int __msgid, const string_type& __s) const
+      { return this->do_get(__c, __set, __msgid, __s); }
+# 1790 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      void
+      close(catalog __c) const
+      { return this->do_close(__c); }
+
+    protected:
+
+      virtual
+      ~messages();
+# 1810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual catalog
+      do_open(const basic_string<char>&, const locale&) const;
+# 1829 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+      virtual string_type
+      do_get(catalog, int, int, const string_type& __dfault) const;
+
+
+
+
+
+
+      virtual void
+      do_close(catalog) const;
+
+
+      char*
+      _M_convert_to_char(const string_type& __msg) const
+      {
+
+ return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
+      }
+
+
+      string_type
+      _M_convert_from_char(char*) const
+      {
+# 1886 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 3
+ return string_type();
+      }
+     };
+
+  template<typename _CharT>
+    locale::id messages<_CharT>::id;
+
+
+  template<>
+    string
+    messages<char>::do_get(catalog, int, int, const string&) const;
+
+
+  template<>
+    wstring
+    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;
+
+
+
+   template<typename _CharT>
+    class messages_byname : public messages<_CharT>
+    {
+    public:
+      typedef _CharT char_type;
+      typedef basic_string<_CharT> string_type;
+
+      explicit
+      messages_byname(const char* __s, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~messages_byname()
+      { }
+    };
+
+}
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 3
+# 1 "/usr/include/libintl.h" 1 3 4
+# 35 "/usr/include/libintl.h" 3 4
+extern "C" {
+
+
+
+
+extern char *gettext (__const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (1)));
+
+
+
+extern char *dgettext (__const char *__domainname, __const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *__dgettext (__const char *__domainname, __const char *__msgid)
+     throw () __attribute__ ((__format_arg__ (2)));
+
+
+
+extern char *dcgettext (__const char *__domainname,
+   __const char *__msgid, int __category)
+     throw () __attribute__ ((__format_arg__ (2)));
+extern char *__dcgettext (__const char *__domainname,
+     __const char *__msgid, int __category)
+     throw () __attribute__ ((__format_arg__ (2)));
+
+
+
+
+extern char *ngettext (__const char *__msgid1, __const char *__msgid2,
+         unsigned long int __n)
+     throw () __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));
+
+
+
+extern char *dngettext (__const char *__domainname, __const char *__msgid1,
+   __const char *__msgid2, unsigned long int __n)
+     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+
+
+
+extern char *dcngettext (__const char *__domainname, __const char *__msgid1,
+    __const char *__msgid2, unsigned long int __n,
+    int __category)
+     throw () __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));
+
+
+
+
+
+extern char *textdomain (__const char *__domainname) throw ();
+
+
+
+extern char *bindtextdomain (__const char *__domainname,
+        __const char *__dirname) throw ();
+
+
+
+extern char *bind_textdomain_codeset (__const char *__domainname,
+          __const char *__codeset) throw ();
+# 122 "/usr/include/libintl.h" 3 4
+}
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/x86_64-pc-linux-gnu/bits/messages_members.h" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  template<typename _CharT>
+     messages<_CharT>::messages(size_t __refs)
+     : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
+       _M_name_messages(_S_get_c_name())
+     { }
+
+  template<typename _CharT>
+     messages<_CharT>::messages(__c_locale __cloc, const char* __s,
+    size_t __refs)
+     : facet(__refs), _M_c_locale_messages(__null), _M_name_messages(__null)
+     {
+       if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
+  {
+    const size_t __len = __builtin_strlen(__s) + 1;
+    char* __tmp = new char[__len];
+    __builtin_memcpy(__tmp, __s, __len);
+    _M_name_messages = __tmp;
+  }
+       else
+  _M_name_messages = _S_get_c_name();
+
+
+       _M_c_locale_messages = _S_clone_c_locale(__cloc);
+     }
+
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
+      const char* __dir) const
+    {
+      bindtextdomain(__s.c_str(), __dir);
+      return this->do_open(__s, __loc);
+    }
+
+
+  template<typename _CharT>
+    messages<_CharT>::~messages()
+    {
+      if (_M_name_messages != _S_get_c_name())
+ delete [] _M_name_messages;
+      _S_destroy_c_locale(_M_c_locale_messages);
+    }
+
+  template<typename _CharT>
+    typename messages<_CharT>::catalog
+    messages<_CharT>::do_open(const basic_string<char>& __s,
+         const locale&) const
+    {
+
+
+      textdomain(__s.c_str());
+      return 0;
+    }
+
+  template<typename _CharT>
+    void
+    messages<_CharT>::do_close(catalog) const
+    { }
+
+
+   template<typename _CharT>
+     messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
+     : messages<_CharT>(__refs)
+     {
+       if (this->_M_name_messages != locale::facet::_S_get_c_name())
+  {
+    delete [] this->_M_name_messages;
+    if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
+      {
+        const size_t __len = __builtin_strlen(__s) + 1;
+        char* __tmp = new char[__len];
+        __builtin_memcpy(__tmp, __s, __len);
+        this->_M_name_messages = __tmp;
+      }
+    else
+      this->_M_name_messages = locale::facet::_S_get_c_name();
+  }
+
+       if (__builtin_strcmp(__s, "C") != 0
+    && __builtin_strcmp(__s, "POSIX") != 0)
+  {
+    this->_S_destroy_c_locale(this->_M_c_locale_messages);
+    this->_S_create_c_locale(this->_M_c_locale_messages, __s);
+  }
+     }
+
+}
+# 1925 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 1 3
+# 40 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+       
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+
+  class codecvt_base
+  {
+  public:
+    enum result
+    {
+      ok,
+      partial,
+      error,
+      noconv
+    };
+  };
+# 66 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class __codecvt_abstract_base
+    : public locale::facet, public codecvt_base
+    {
+    public:
+
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+# 114 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+      result
+      out(state_type& __state, const intern_type* __from,
+   const intern_type* __from_end, const intern_type*& __from_next,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const
+      {
+ return this->do_out(__state, __from, __from_end, __from_next,
+       __to, __to_end, __to_next);
+      }
+# 153 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+      result
+      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
+       extern_type*& __to_next) const
+      { return this->do_unshift(__state, __to,__to_end,__to_next); }
+# 194 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+      result
+      in(state_type& __state, const extern_type* __from,
+  const extern_type* __from_end, const extern_type*& __from_next,
+  intern_type* __to, intern_type* __to_end,
+  intern_type*& __to_next) const
+      {
+ return this->do_in(__state, __from, __from_end, __from_next,
+      __to, __to_end, __to_next);
+      }
+
+      int
+      encoding() const throw()
+      { return this->do_encoding(); }
+
+      bool
+      always_noconv() const throw()
+      { return this->do_always_noconv(); }
+
+      int
+      length(state_type& __state, const extern_type* __from,
+      const extern_type* __end, size_t __max) const
+      { return this->do_length(__state, __from, __end, __max); }
+
+      int
+      max_length() const throw()
+      { return this->do_max_length(); }
+
+    protected:
+      explicit
+      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }
+
+      virtual
+      ~__codecvt_abstract_base() { }
+# 235 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const = 0;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const = 0;
+
+      virtual int
+      do_encoding() const throw() = 0;
+
+      virtual bool
+      do_always_noconv() const throw() = 0;
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const = 0;
+
+      virtual int
+      do_max_length() const throw() = 0;
+    };
+# 274 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/codecvt.h" 3
+   template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt
+    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
+    {
+    public:
+
+      typedef codecvt_base::result result;
+      typedef _InternT intern_type;
+      typedef _ExternT extern_type;
+      typedef _StateT state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0)
+      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs) { }
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt() { }
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    locale::id codecvt<_InternT, _ExternT, _StateT>::id;
+
+
+  template<>
+    class codecvt<char, char, mbstate_t>
+    : public __codecvt_abstract_base<char, char, mbstate_t>
+    {
+    public:
+
+      typedef char intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state, extern_type* __to,
+   extern_type* __to_end, extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state, const extern_type* __from,
+     const extern_type* __from_end, const extern_type*& __from_next,
+     intern_type* __to, intern_type* __to_end,
+     intern_type*& __to_next) const;
+
+      virtual int
+      do_encoding() const throw();
+
+      virtual bool
+      do_always_noconv() const throw();
+
+      virtual int
+      do_length(state_type&, const extern_type* __from,
+  const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+  };
+
+
+
+  template<>
+    class codecvt<wchar_t, char, mbstate_t>
+    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
+    {
+    public:
+
+      typedef wchar_t intern_type;
+      typedef char extern_type;
+      typedef mbstate_t state_type;
+
+    protected:
+      __c_locale _M_c_locale_codecvt;
+
+    public:
+      static locale::id id;
+
+      explicit
+      codecvt(size_t __refs = 0);
+
+      explicit
+      codecvt(__c_locale __cloc, size_t __refs = 0);
+
+    protected:
+      virtual
+      ~codecvt();
+
+      virtual result
+      do_out(state_type& __state, const intern_type* __from,
+      const intern_type* __from_end, const intern_type*& __from_next,
+      extern_type* __to, extern_type* __to_end,
+      extern_type*& __to_next) const;
+
+      virtual result
+      do_unshift(state_type& __state,
+   extern_type* __to, extern_type* __to_end,
+   extern_type*& __to_next) const;
+
+      virtual result
+      do_in(state_type& __state,
+      const extern_type* __from, const extern_type* __from_end,
+      const extern_type*& __from_next,
+      intern_type* __to, intern_type* __to_end,
+      intern_type*& __to_next) const;
+
+      virtual
+      int do_encoding() const throw();
+
+      virtual
+      bool do_always_noconv() const throw();
+
+      virtual
+      int do_length(state_type&, const extern_type* __from,
+      const extern_type* __end, size_t __max) const;
+
+      virtual int
+      do_max_length() const throw();
+    };
+
+
+
+  template<typename _InternT, typename _ExternT, typename _StateT>
+    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
+    {
+    public:
+      explicit
+      codecvt_byname(const char* __s, size_t __refs = 0)
+      : codecvt<_InternT, _ExternT, _StateT>(__refs)
+      {
+ if (__builtin_strcmp(__s, "C") != 0
+     && __builtin_strcmp(__s, "POSIX") != 0)
+   {
+     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
+     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
+   }
+      }
+
+    protected:
+      virtual
+      ~codecvt_byname() { }
+    };
+
+
+
+
+
+  extern template class codecvt_byname<char, char, mbstate_t>;
+
+  extern template
+    const codecvt<char, char, mbstate_t>&
+    use_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<char, char, mbstate_t> >(const locale&);
+
+
+  extern template class codecvt_byname<wchar_t, char, mbstate_t>;
+
+  extern template
+    const codecvt<wchar_t, char, mbstate_t>&
+    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);
+
+
+
+}
+# 1928 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 1 3
+# 33 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
+       
+# 34 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+
+  template<typename _CharT, bool _Intl>
+    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
+    {
+      const __moneypunct_cache<_CharT, _Intl>*
+      operator() (const locale& __loc) const
+      {
+ const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
+ const locale::facet** __caches = __loc._M_impl->_M_caches;
+ if (!__caches[__i])
+   {
+     __moneypunct_cache<_CharT, _Intl>* __tmp = __null;
+     try
+       {
+  __tmp = new __moneypunct_cache<_CharT, _Intl>;
+  __tmp->_M_cache(__loc);
+       }
+     catch(...)
+       {
+  delete __tmp;
+  throw;
+       }
+     __loc._M_impl->_M_install_cache(__tmp, __i);
+   }
+ return static_cast<
+   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
+      }
+    };
+
+  template<typename _CharT, bool _Intl>
+    void
+    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
+    {
+      _M_allocated = true;
+
+      const moneypunct<_CharT, _Intl>& __mp =
+ use_facet<moneypunct<_CharT, _Intl> >(__loc);
+
+      _M_decimal_point = __mp.decimal_point();
+      _M_thousands_sep = __mp.thousands_sep();
+      _M_frac_digits = __mp.frac_digits();
+
+      char* __grouping = 0;
+      _CharT* __curr_symbol = 0;
+      _CharT* __positive_sign = 0;
+      _CharT* __negative_sign = 0;
+      try
+ {
+   _M_grouping_size = __mp.grouping().size();
+   __grouping = new char[_M_grouping_size];
+   __mp.grouping().copy(__grouping, _M_grouping_size);
+   _M_grouping = __grouping;
+   _M_use_grouping = (_M_grouping_size
+        && static_cast<signed char>(_M_grouping[0]) > 0
+        && (_M_grouping[0]
+     != __gnu_cxx::__numeric_traits<char>::__max));
+
+   _M_curr_symbol_size = __mp.curr_symbol().size();
+   __curr_symbol = new _CharT[_M_curr_symbol_size];
+   __mp.curr_symbol().copy(__curr_symbol, _M_curr_symbol_size);
+   _M_curr_symbol = __curr_symbol;
+
+   _M_positive_sign_size = __mp.positive_sign().size();
+   __positive_sign = new _CharT[_M_positive_sign_size];
+   __mp.positive_sign().copy(__positive_sign, _M_positive_sign_size);
+   _M_positive_sign = __positive_sign;
+
+   _M_negative_sign_size = __mp.negative_sign().size();
+   __negative_sign = new _CharT[_M_negative_sign_size];
+   __mp.negative_sign().copy(__negative_sign, _M_negative_sign_size);
+   _M_negative_sign = __negative_sign;
+
+   _M_pos_format = __mp.pos_format();
+   _M_neg_format = __mp.neg_format();
+
+   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
+   __ct.widen(money_base::_S_atoms,
+       money_base::_S_atoms + money_base::_S_end, _M_atoms);
+ }
+      catch(...)
+ {
+   delete [] __grouping;
+   delete [] __curr_symbol;
+   delete [] __positive_sign;
+   delete [] __negative_sign;
+   throw;
+ }
+    }
+
+
+
+  template<typename _CharT, typename _InIter>
+    template<bool _Intl>
+      _InIter
+      money_get<_CharT, _InIter>::
+      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
+   ios_base::iostate& __err, string& __units) const
+      {
+ typedef char_traits<_CharT> __traits_type;
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+
+
+ bool __negative = false;
+
+ size_type __sign_size = 0;
+
+ const bool __mandatory_sign = (__lc->_M_positive_sign_size
+           && __lc->_M_negative_sign_size);
+
+ string __grouping_tmp;
+ if (__lc->_M_use_grouping)
+   __grouping_tmp.reserve(32);
+
+ int __last_pos = 0;
+
+ int __n = 0;
+
+ bool __testvalid = true;
+
+ bool __testdecfound = false;
+
+
+ string __res;
+ __res.reserve(32);
+
+ const char_type* __lit_zero = __lit + money_base::_S_zero;
+ const money_base::pattern __p = __lc->_M_neg_format;
+ for (int __i = 0; __i < 4 && __testvalid; ++__i)
+   {
+     const part __which = static_cast<part>(__p.field[__i]);
+     switch (__which)
+       {
+       case money_base::symbol:
+
+
+
+
+  if (__io.flags() & ios_base::showbase || __sign_size > 1
+      || __i == 0
+      || (__i == 1 && (__mandatory_sign
+         || (static_cast<part>(__p.field[0])
+      == money_base::sign)
+         || (static_cast<part>(__p.field[2])
+      == money_base::space)))
+      || (__i == 2 && ((static_cast<part>(__p.field[3])
+          == money_base::value)
+         || (__mandatory_sign
+      && (static_cast<part>(__p.field[3])
+          == money_base::sign)))))
+    {
+      const size_type __len = __lc->_M_curr_symbol_size;
+      size_type __j = 0;
+      for (; __beg != __end && __j < __len
+      && *__beg == __lc->_M_curr_symbol[__j];
+    ++__beg, ++__j);
+      if (__j != __len
+   && (__j || __io.flags() & ios_base::showbase))
+        __testvalid = false;
+    }
+  break;
+       case money_base::sign:
+
+  if (__lc->_M_positive_sign_size && __beg != __end
+      && *__beg == __lc->_M_positive_sign[0])
+    {
+      __sign_size = __lc->_M_positive_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_negative_sign_size && __beg != __end
+    && *__beg == __lc->_M_negative_sign[0])
+    {
+      __negative = true;
+      __sign_size = __lc->_M_negative_sign_size;
+      ++__beg;
+    }
+  else if (__lc->_M_positive_sign_size
+    && !__lc->_M_negative_sign_size)
+
+
+    __negative = true;
+  else if (__mandatory_sign)
+    __testvalid = false;
+  break;
+       case money_base::value:
+
+
+  for (; __beg != __end; ++__beg)
+    {
+      const char_type __c = *__beg;
+      const char_type* __q = __traits_type::find(__lit_zero,
+              10, __c);
+      if (__q != 0)
+        {
+   __res += money_base::_S_atoms[__q - __lit];
+   ++__n;
+        }
+      else if (__c == __lc->_M_decimal_point
+        && !__testdecfound)
+        {
+   if (__lc->_M_frac_digits <= 0)
+     break;
+
+   __last_pos = __n;
+   __n = 0;
+   __testdecfound = true;
+        }
+      else if (__lc->_M_use_grouping
+        && __c == __lc->_M_thousands_sep
+        && !__testdecfound)
+        {
+   if (__n)
+     {
+
+       __grouping_tmp += static_cast<char>(__n);
+       __n = 0;
+     }
+   else
+     {
+       __testvalid = false;
+       break;
+     }
+        }
+      else
+        break;
+    }
+  if (__res.empty())
+    __testvalid = false;
+  break;
+       case money_base::space:
+
+  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
+    ++__beg;
+  else
+    __testvalid = false;
+       case money_base::none:
+
+  if (__i != 3)
+    for (; __beg != __end
+    && __ctype.is(ctype_base::space, *__beg); ++__beg);
+  break;
+       }
+   }
+
+
+ if (__sign_size > 1 && __testvalid)
+   {
+     const char_type* __sign = __negative ? __lc->_M_negative_sign
+                                          : __lc->_M_positive_sign;
+     size_type __i = 1;
+     for (; __beg != __end && __i < __sign_size
+     && *__beg == __sign[__i]; ++__beg, ++__i);
+
+     if (__i != __sign_size)
+       __testvalid = false;
+   }
+
+ if (__testvalid)
+   {
+
+     if (__res.size() > 1)
+       {
+  const size_type __first = __res.find_first_not_of('0');
+  const bool __only_zeros = __first == string::npos;
+  if (__first)
+    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
+       }
+
+
+     if (__negative && __res[0] != '0')
+       __res.insert(__res.begin(), '-');
+
+
+     if (__grouping_tmp.size())
+       {
+
+  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
+                         : __n);
+  if (!std::__verify_grouping(__lc->_M_grouping,
+         __lc->_M_grouping_size,
+         __grouping_tmp))
+    __err |= ios_base::failbit;
+       }
+
+
+     if (__testdecfound && __n != __lc->_M_frac_digits)
+       __testvalid = false;
+   }
+
+
+ if (!__testvalid)
+   __err |= ios_base::failbit;
+ else
+   __units.swap(__res);
+
+
+ if (__beg == __end)
+   __err |= ios_base::eofbit;
+ return __beg;
+      }
+# 360 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, long double& __units) const
+    {
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    money_get<_CharT, _InIter>::
+    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
+    ios_base::iostate& __err, string_type& __digits) const
+    {
+      typedef typename string::size_type size_type;
+
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      string __str;
+      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
+              : _M_extract<false>(__beg, __end, __io, __err, __str);
+      const size_type __len = __str.size();
+      if (__len)
+ {
+   __digits.resize(__len);
+   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
+ }
+      return __beg;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    template<bool _Intl>
+      _OutIter
+      money_put<_CharT, _OutIter>::
+      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
+  const string_type& __digits) const
+      {
+ typedef typename string_type::size_type size_type;
+ typedef money_base::part part;
+ typedef __moneypunct_cache<_CharT, _Intl> __cache_type;
+
+ const locale& __loc = __io._M_getloc();
+ const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+ __use_cache<__cache_type> __uc;
+ const __cache_type* __lc = __uc(__loc);
+ const char_type* __lit = __lc->_M_atoms;
+
+
+
+ const char_type* __beg = __digits.data();
+
+ money_base::pattern __p;
+ const char_type* __sign;
+ size_type __sign_size;
+ if (!(*__beg == __lit[money_base::_S_minus]))
+   {
+     __p = __lc->_M_pos_format;
+     __sign = __lc->_M_positive_sign;
+     __sign_size = __lc->_M_positive_sign_size;
+   }
+ else
+   {
+     __p = __lc->_M_neg_format;
+     __sign = __lc->_M_negative_sign;
+     __sign_size = __lc->_M_negative_sign_size;
+     if (__digits.size())
+       ++__beg;
+   }
+
+
+ size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
+        __beg + __digits.size()) - __beg;
+ if (__len)
+   {
+
+
+
+     string_type __value;
+     __value.reserve(2 * __len);
+
+
+
+     long __paddec = __len - __lc->_M_frac_digits;
+     if (__paddec > 0)
+         {
+  if (__lc->_M_frac_digits < 0)
+    __paddec = __len;
+    if (__lc->_M_grouping_size)
+      {
+      __value.assign(2 * __paddec, char_type());
+       _CharT* __vend =
+        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
+       __lc->_M_grouping,
+       __lc->_M_grouping_size,
+       __beg, __beg + __paddec);
+      __value.erase(__vend - &__value[0]);
+      }
+    else
+    __value.assign(__beg, __paddec);
+       }
+
+
+     if (__lc->_M_frac_digits > 0)
+       {
+  __value += __lc->_M_decimal_point;
+  if (__paddec >= 0)
+    __value.append(__beg + __paddec, __lc->_M_frac_digits);
+  else
+    {
+
+      __value.append(-__paddec, __lit[money_base::_S_zero]);
+      __value.append(__beg, __len);
+    }
+         }
+
+
+     const ios_base::fmtflags __f = __io.flags()
+                                    & ios_base::adjustfield;
+     __len = __value.size() + __sign_size;
+     __len += ((__io.flags() & ios_base::showbase)
+        ? __lc->_M_curr_symbol_size : 0);
+
+     string_type __res;
+     __res.reserve(2 * __len);
+
+     const size_type __width = static_cast<size_type>(__io.width());
+     const bool __testipad = (__f == ios_base::internal
+         && __len < __width);
+
+     for (int __i = 0; __i < 4; ++__i)
+       {
+  const part __which = static_cast<part>(__p.field[__i]);
+  switch (__which)
+    {
+    case money_base::symbol:
+      if (__io.flags() & ios_base::showbase)
+        __res.append(__lc->_M_curr_symbol,
+       __lc->_M_curr_symbol_size);
+      break;
+    case money_base::sign:
+
+
+
+      if (__sign_size)
+        __res += __sign[0];
+      break;
+    case money_base::value:
+      __res += __value;
+      break;
+    case money_base::space:
+
+
+
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      else
+        __res += __fill;
+      break;
+    case money_base::none:
+      if (__testipad)
+        __res.append(__width - __len, __fill);
+      break;
+    }
+       }
+
+
+     if (__sign_size > 1)
+       __res.append(__sign + 1, __sign_size - 1);
+
+
+     __len = __res.size();
+     if (__width > __len)
+       {
+  if (__f == ios_base::left)
+
+    __res.append(__width - __len, __fill);
+  else
+
+    __res.insert(0, __width - __len, __fill);
+  __len = __width;
+       }
+
+
+     __s = std::__write(__s, __res.data(), __len);
+   }
+ __io.width(0);
+ return __s;
+      }
+# 565 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    long double __units) const
+    {
+      const locale __loc = __io.getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+
+      int __cs_size = 64;
+      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+
+
+      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+
+      if (__len >= __cs_size)
+ {
+   __cs_size = __len + 1;
+   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
+   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
+     "%.*Lf", 0, __units);
+ }
+# 597 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.tcc" 3
+      string_type __digits(__len, char_type());
+      __ctype.widen(__cs, __cs + __len, &__digits[0]);
+      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits);
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    money_put<_CharT, _OutIter>::
+    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
+    const string_type& __digits) const
+    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
+             : _M_insert<false>(__s, __io, __fill, __digits); }
+
+
+
+
+
+
+  template<typename _CharT, typename _InIter>
+    time_base::dateorder
+    time_get<_CharT, _InIter>::do_date_order() const
+    { return time_base::no_order; }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm,
+     const _CharT* __format) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const size_t __len = char_traits<_CharT>::length(__format);
+
+      ios_base::iostate __tmperr = ios_base::goodbit;
+      for (size_t __i = 0; __beg != __end && __i < __len && !__tmperr; ++__i)
+ {
+   if (__ctype.narrow(__format[__i], 0) == '%')
+     {
+
+       char __c = __ctype.narrow(__format[++__i], 0);
+       int __mem = 0;
+       if (__c == 'E' || __c == 'O')
+  __c = __ctype.narrow(__format[++__i], 0);
+       switch (__c)
+  {
+    const char* __cs;
+    _CharT __wcs[10];
+  case 'a':
+
+    const char_type* __days1[7];
+    __tp._M_days_abbreviated(__days1);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days1,
+       7, __io, __tmperr);
+    break;
+  case 'A':
+
+    const char_type* __days2[7];
+    __tp._M_days(__days2);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_wday, __days2,
+       7, __io, __tmperr);
+    break;
+  case 'h':
+  case 'b':
+
+    const char_type* __months1[12];
+    __tp._M_months_abbreviated(__months1);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
+       __months1, 12, __io, __tmperr);
+    break;
+  case 'B':
+
+    const char_type* __months2[12];
+    __tp._M_months(__months2);
+    __beg = _M_extract_name(__beg, __end, __tm->tm_mon,
+       __months2, 12, __io, __tmperr);
+    break;
+  case 'c':
+
+    const char_type* __dt[2];
+    __tp._M_date_time_formats(__dt);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dt[0]);
+    break;
+  case 'd':
+
+    __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 1, 31, 2,
+      __io, __tmperr);
+    break;
+  case 'e':
+
+
+    if (__ctype.is(ctype_base::space, *__beg))
+      __beg = _M_extract_num(++__beg, __end, __tm->tm_mday, 1, 9,
+        1, __io, __tmperr);
+    else
+      __beg = _M_extract_num(__beg, __end, __tm->tm_mday, 10, 31,
+        2, __io, __tmperr);
+    break;
+  case 'D':
+
+    __cs = "%m/%d/%y";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'H':
+
+    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 0, 23, 2,
+      __io, __tmperr);
+    break;
+  case 'I':
+
+    __beg = _M_extract_num(__beg, __end, __tm->tm_hour, 1, 12, 2,
+      __io, __tmperr);
+    break;
+  case 'm':
+
+    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_mon = __mem - 1;
+    break;
+  case 'M':
+
+    __beg = _M_extract_num(__beg, __end, __tm->tm_min, 0, 59, 2,
+      __io, __tmperr);
+    break;
+  case 'n':
+    if (__ctype.narrow(*__beg, 0) == '\n')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'R':
+
+    __cs = "%H:%M";
+    __ctype.widen(__cs, __cs + 6, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'S':
+
+
+
+    __beg = _M_extract_num(__beg, __end, __tm->tm_sec, 0, 60, 2,
+
+
+
+      __io, __tmperr);
+    break;
+  case 't':
+    if (__ctype.narrow(*__beg, 0) == '\t')
+      ++__beg;
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  case 'T':
+
+    __cs = "%H:%M:%S";
+    __ctype.widen(__cs, __cs + 9, __wcs);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __wcs);
+    break;
+  case 'x':
+
+    const char_type* __dates[2];
+    __tp._M_date_formats(__dates);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __dates[0]);
+    break;
+  case 'X':
+
+    const char_type* __times[2];
+    __tp._M_time_formats(__times);
+    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
+      __tm, __times[0]);
+    break;
+  case 'y':
+  case 'C':
+
+  case 'Y':
+
+
+
+
+    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
+      __io, __tmperr);
+    if (!__tmperr)
+      __tm->tm_year = __mem < 0 ? __mem + 100 : __mem - 1900;
+    break;
+  case 'Z':
+
+    if (__ctype.is(ctype_base::upper, *__beg))
+      {
+        int __tmp;
+        __beg = _M_extract_name(__beg, __end, __tmp,
+           __timepunct_cache<_CharT>::_S_timezones,
+           14, __io, __tmperr);
+
+
+        if (__beg != __end && !__tmperr && __tmp == 0
+     && (*__beg == __ctype.widen('-')
+         || *__beg == __ctype.widen('+')))
+   {
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
+       __io, __tmperr);
+     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
+       __io, __tmperr);
+   }
+      }
+    else
+      __tmperr |= ios_base::failbit;
+    break;
+  default:
+
+    __tmperr |= ios_base::failbit;
+  }
+     }
+   else
+     {
+
+       if (__format[__i] == *__beg)
+  ++__beg;
+       else
+  __tmperr |= ios_base::failbit;
+     }
+ }
+
+      if (__tmperr)
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
+     int __min, int __max, size_t __len,
+     ios_base& __io, ios_base::iostate& __err) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+
+      int __mult = __len == 2 ? 10 : (__len == 4 ? 1000 : 1);
+
+      ++__min;
+      size_t __i = 0;
+      int __value = 0;
+      for (; __beg != __end && __i < __len; ++__beg, ++__i)
+ {
+   const char __c = __ctype.narrow(*__beg, '*');
+   if (__c >= '0' && __c <= '9')
+     {
+       __value = __value * 10 + (__c - '0');
+       const int __valuec = __value * __mult;
+       if (__valuec > __max || __valuec + __mult < __min)
+  break;
+       __mult /= 10;
+     }
+   else
+     break;
+ }
+      if (__i == __len)
+ __member = __value;
+
+      else if (__len == 4 && __i == 2)
+ __member = __value - 100;
+      else
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
+      const _CharT** __names, size_t __indexlen,
+      ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t __pos = 0;
+      bool __testvalid = true;
+      const char_type* __name;
+
+
+
+
+
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
+     if (__c == __names[__i1][0]
+  || __c == __ctype.toupper(__names[__i1][0]))
+       __matches[__nmatches++] = __i1;
+ }
+
+      while (__nmatches > 1)
+ {
+
+   size_t __minlen = __traits_type::length(__names[__matches[0]]);
+   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
+     __minlen = std::min(__minlen,
+         __traits_type::length(__names[__matches[__i2]]));
+   ++__beg, ++__pos;
+   if (__pos < __minlen && __beg != __end)
+     for (size_t __i3 = 0; __i3 < __nmatches;)
+       {
+  __name = __names[__matches[__i3]];
+  if (!(__name[__pos] == *__beg))
+    __matches[__i3] = __matches[--__nmatches];
+  else
+    ++__i3;
+       }
+   else
+     break;
+ }
+
+      if (__nmatches == 1)
+ {
+
+   ++__beg, ++__pos;
+   __name = __names[__matches[0]];
+   const size_t __len = __traits_type::length(__name);
+   while (__pos < __len && __beg != __end && __name[__pos] == *__beg)
+     ++__beg, ++__pos;
+
+   if (__len == __pos)
+     __member = __matches[0];
+   else
+     __testvalid = false;
+ }
+      else
+ __testvalid = false;
+      if (!__testvalid)
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
+        const _CharT** __names, size_t __indexlen,
+        ios_base& __io, ios_base::iostate& __err) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+
+      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
+         * __indexlen));
+      size_t __nmatches = 0;
+      size_t* __matches_lengths = 0;
+      size_t __pos = 0;
+
+      if (__beg != __end)
+ {
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
+     if (__c == __names[__i][0]
+  || __c == __ctype.toupper(__names[__i][0]))
+       __matches[__nmatches++] = __i;
+ }
+
+      if (__nmatches)
+ {
+   ++__beg, ++__pos;
+
+   __matches_lengths
+     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
+          * __nmatches));
+   for (size_t __i = 0; __i < __nmatches; ++__i)
+     __matches_lengths[__i]
+       = __traits_type::length(__names[__matches[__i]]);
+ }
+
+      for (; __beg != __end; ++__beg, ++__pos)
+ {
+   size_t __nskipped = 0;
+   const char_type __c = *__beg;
+   for (size_t __i = 0; __i < __nmatches;)
+     {
+       const char_type* __name = __names[__matches[__i]];
+       if (__pos >= __matches_lengths[__i])
+  ++__nskipped, ++__i;
+       else if (!(__name[__pos] == __c))
+  {
+    --__nmatches;
+    __matches[__i] = __matches[__nmatches];
+    __matches_lengths[__i] = __matches_lengths[__nmatches];
+  }
+       else
+  ++__i;
+     }
+   if (__nskipped == __nmatches)
+     break;
+ }
+
+      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
+   || (__nmatches == 2 && (__matches_lengths[0] == __pos
+      || __matches_lengths[1] == __pos)))
+ __member = (__matches[0] >= __indexlen
+      ? __matches[0] - __indexlen : __matches[0]);
+      else
+ __err |= ios_base::failbit;
+
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __times[2];
+      __tp._M_time_formats(__times);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __times[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const char_type* __dates[2];
+      __tp._M_date_formats(__dates);
+      __beg = _M_extract_via_format(__beg, __end, __io, __err,
+        __tm, __dates[0]);
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
+     ios_base::iostate& __err, tm* __tm) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const char_type* __days[14];
+      __tp._M_days_abbreviated(__days);
+      __tp._M_days(__days + 7);
+      int __tmpwday;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_wday = __tmpwday;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+     }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_monthname(iter_type __beg, iter_type __end,
+                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
+    {
+      typedef char_traits<_CharT> __traits_type;
+      const locale& __loc = __io._M_getloc();
+      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      const char_type* __months[24];
+      __tp._M_months_abbreviated(__months);
+      __tp._M_months(__months + 12);
+      int __tmpmon;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
+           __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_mon = __tmpmon;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _InIter>
+    _InIter
+    time_get<_CharT, _InIter>::
+    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
+  ios_base::iostate& __err, tm* __tm) const
+    {
+      const locale& __loc = __io._M_getloc();
+      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
+      int __tmpyear;
+      ios_base::iostate __tmperr = ios_base::goodbit;
+
+      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 9999, 4,
+        __io, __tmperr);
+      if (!__tmperr)
+ __tm->tm_year = __tmpyear < 0 ? __tmpyear + 100 : __tmpyear - 1900;
+      else
+ __err |= ios_base::failbit;
+
+      if (__beg == __end)
+ __err |= ios_base::eofbit;
+      return __beg;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
+ const _CharT* __beg, const _CharT* __end) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      for (; __beg != __end; ++__beg)
+ if (__ctype.narrow(*__beg, 0) != '%')
+   {
+     *__s = *__beg;
+     ++__s;
+   }
+ else if (++__beg != __end)
+   {
+     char __format;
+     char __mod = 0;
+     const char __c = __ctype.narrow(*__beg, 0);
+     if (__c != 'E' && __c != 'O')
+       __format = __c;
+     else if (++__beg != __end)
+       {
+  __mod = __c;
+  __format = __ctype.narrow(*__beg, 0);
+       }
+     else
+       break;
+     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
+   }
+ else
+   break;
+      return __s;
+    }
+
+  template<typename _CharT, typename _OutIter>
+    _OutIter
+    time_put<_CharT, _OutIter>::
+    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
+    char __format, char __mod) const
+    {
+      const locale& __loc = __io._M_getloc();
+      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
+      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);
+
+
+
+      const size_t __maxlen = 128;
+      char_type __res[__maxlen];
+
+
+
+
+
+
+      char_type __fmt[4];
+      __fmt[0] = __ctype.widen('%');
+      if (!__mod)
+ {
+   __fmt[1] = __format;
+   __fmt[2] = char_type();
+ }
+      else
+ {
+   __fmt[1] = __mod;
+   __fmt[2] = __format;
+   __fmt[3] = char_type();
+ }
+
+      __tp._M_put(__res, __maxlen, __fmt, __tm);
+
+
+      return std::__write(__s, __res, char_traits<char_type>::length(__res));
+    }
+
+
+
+
+
+
+  extern template class moneypunct<char, false>;
+  extern template class moneypunct<char, true>;
+  extern template class moneypunct_byname<char, false>;
+  extern template class moneypunct_byname<char, true>;
+  extern template class money_get<char>;
+  extern template class money_put<char>;
+  extern template class __timepunct<char>;
+  extern template class time_put<char>;
+  extern template class time_put_byname<char>;
+  extern template class time_get<char>;
+  extern template class time_get_byname<char>;
+  extern template class messages<char>;
+  extern template class messages_byname<char>;
+
+  extern template
+    const moneypunct<char, true>&
+    use_facet<moneypunct<char, true> >(const locale&);
+
+  extern template
+    const moneypunct<char, false>&
+    use_facet<moneypunct<char, false> >(const locale&);
+
+  extern template
+    const money_put<char>&
+    use_facet<money_put<char> >(const locale&);
+
+  extern template
+    const money_get<char>&
+    use_facet<money_get<char> >(const locale&);
+
+  extern template
+    const __timepunct<char>&
+    use_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    const time_put<char>&
+    use_facet<time_put<char> >(const locale&);
+
+  extern template
+    const time_get<char>&
+    use_facet<time_get<char> >(const locale&);
+
+  extern template
+    const messages<char>&
+    use_facet<messages<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<char> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<char> >(const locale&);
+
+
+  extern template class moneypunct<wchar_t, false>;
+  extern template class moneypunct<wchar_t, true>;
+  extern template class moneypunct_byname<wchar_t, false>;
+  extern template class moneypunct_byname<wchar_t, true>;
+  extern template class money_get<wchar_t>;
+  extern template class money_put<wchar_t>;
+  extern template class __timepunct<wchar_t>;
+  extern template class time_put<wchar_t>;
+  extern template class time_put_byname<wchar_t>;
+  extern template class time_get<wchar_t>;
+  extern template class time_get_byname<wchar_t>;
+  extern template class messages<wchar_t>;
+  extern template class messages_byname<wchar_t>;
+
+  extern template
+    const moneypunct<wchar_t, true>&
+    use_facet<moneypunct<wchar_t, true> >(const locale&);
+
+  extern template
+    const moneypunct<wchar_t, false>&
+    use_facet<moneypunct<wchar_t, false> >(const locale&);
+
+  extern template
+    const money_put<wchar_t>&
+    use_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    const money_get<wchar_t>&
+    use_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    const __timepunct<wchar_t>&
+    use_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    const time_put<wchar_t>&
+    use_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    const time_get<wchar_t>&
+    use_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    const messages<wchar_t>&
+    use_facet<messages<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<moneypunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<money_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<__timepunct<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_put<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<time_get<wchar_t> >(const locale&);
+
+  extern template
+    bool
+    has_facet<messages<wchar_t> >(const locale&);
+
+
+
+}
+# 1931 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/locale_facets_nonio.h" 2 3
+# 44 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/locale" 2 3
+# 36 "/usr/include/boost-1_42/boost/lexical_cast.hpp" 2
+# 55 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+namespace boost
+{
+
+    class bad_lexical_cast : public std::bad_cast
+
+
+
+
+
+
+    {
+    public:
+        bad_lexical_cast() :
+
+          source(&typeid(void)), target(&typeid(void))
+
+
+
+        {
+        }
+
+        bad_lexical_cast(
+            const std::type_info &source_type_arg,
+            const std::type_info &target_type_arg) :
+            source(&source_type_arg), target(&target_type_arg)
+        {
+        }
+
+        const std::type_info &source_type() const
+        {
+            return *source;
+        }
+        const std::type_info &target_type() const
+        {
+            return *target;
+        }
+
+        virtual const char *what() const throw()
+        {
+            return "bad lexical cast: "
+                   "source type value could not be interpreted as target";
+        }
+        virtual ~bad_lexical_cast() throw()
+        {
+        }
+    private:
+        const std::type_info *source;
+        const std::type_info *target;
+    };
+
+    namespace detail
+    {
+        template<typename Type>
+        struct stream_char
+        {
+            typedef char type;
+        };
+
+
+        template<class CharT, class Traits, class Alloc>
+        struct stream_char< std::basic_string<CharT,Traits,Alloc> >
+        {
+            typedef CharT type;
+        };
+
+
+
+
+        template<>
+        struct stream_char<wchar_t>
+        {
+            typedef wchar_t type;
+        };
+
+
+        template<>
+        struct stream_char<wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+
+        template<>
+        struct stream_char<const wchar_t *>
+        {
+            typedef wchar_t type;
+        };
+# 151 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template<typename TargetChar, typename SourceChar>
+        struct widest_char
+        {
+            typedef TargetChar type;
+        };
+
+        template<>
+        struct widest_char<char, wchar_t>
+        {
+            typedef wchar_t type;
+        };
+    }
+
+    namespace detail
+    {
+
+        template<class CharT, class Target, class Source>
+        struct deduce_char_traits
+        {
+            typedef std::char_traits<CharT> type;
+        };
+
+        template<class CharT, class Traits, class Alloc, class Source>
+        struct deduce_char_traits< CharT
+                                 , std::basic_string<CharT,Traits,Alloc>
+                                 , Source
+                                 >
+        {
+            typedef Traits type;
+        };
+
+        template<class CharT, class Target, class Traits, class Alloc>
+        struct deduce_char_traits< CharT
+                                 , Target
+                                 , std::basic_string<CharT,Traits,Alloc>
+                                 >
+        {
+            typedef Traits type;
+        };
+
+        template<class CharT, class Traits, class Alloc1, class Alloc2>
+        struct deduce_char_traits< CharT
+                                 , std::basic_string<CharT,Traits,Alloc1>
+                                 , std::basic_string<CharT,Traits,Alloc2>
+                                 >
+        {
+            typedef Traits type;
+        };
+
+    }
+
+    namespace detail
+    {
+# 213 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template< class CharT
+                , class Source
+                >
+        struct lcast_src_length
+        {
+            static const std::size_t value = 0;
+
+
+            static void check_coverage() {}
+        };
+
+        template<>
+        struct lcast_src_length<char, bool>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+        template<>
+        struct lcast_src_length<char, char>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+# 247 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template<>
+        struct lcast_src_length<wchar_t, bool>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+        template<>
+        struct lcast_src_length<wchar_t, char>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+
+        template<>
+        struct lcast_src_length<wchar_t, wchar_t>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+
+
+        template<>
+        struct lcast_src_length<char, char const*>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+        template<>
+        struct lcast_src_length<char, char*>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+
+        template<>
+        struct lcast_src_length<wchar_t, wchar_t const*>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+        template<>
+        struct lcast_src_length<wchar_t, wchar_t*>
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+
+
+
+        template<class CharT, class Traits, class Alloc>
+        struct lcast_src_length< CharT, std::basic_string<CharT,Traits,Alloc> >
+        {
+            static const std::size_t value = 1;
+            static void check_coverage() {}
+        };
+# 339 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template<class Source>
+        struct lcast_src_length_integral
+        {
+
+            static const std::size_t value = std::numeric_limits<Source>::is_signed + std::numeric_limits<Source>::is_specialized + std::numeric_limits<Source>::digits10 * 2
+
+
+
+               ;
+
+
+
+
+        };
+# 367 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template<> struct lcast_src_length<char, short> : lcast_src_length_integral<short> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, short> : lcast_src_length_integral<short> { static void check_coverage() {} };
+        template<> struct lcast_src_length<char, unsigned short> : lcast_src_length_integral<unsigned short> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, unsigned short> : lcast_src_length_integral<unsigned short> { static void check_coverage() {} };
+        template<> struct lcast_src_length<char, int> : lcast_src_length_integral<int> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, int> : lcast_src_length_integral<int> { static void check_coverage() {} };
+        template<> struct lcast_src_length<char, unsigned int> : lcast_src_length_integral<unsigned int> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, unsigned int> : lcast_src_length_integral<unsigned int> { static void check_coverage() {} };
+        template<> struct lcast_src_length<char, long> : lcast_src_length_integral<long> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, long> : lcast_src_length_integral<long> { static void check_coverage() {} };
+        template<> struct lcast_src_length<char, unsigned long> : lcast_src_length_integral<unsigned long> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, unsigned long> : lcast_src_length_integral<unsigned long> { static void check_coverage() {} };
+
+        template<> struct lcast_src_length<char, boost::ulong_long_type> : lcast_src_length_integral<boost::ulong_long_type> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, boost::ulong_long_type> : lcast_src_length_integral<boost::ulong_long_type> { static void check_coverage() {} };
+        template<> struct lcast_src_length<char, boost::long_long_type> : lcast_src_length_integral<boost::long_long_type> { static void check_coverage() {} }; template<> struct lcast_src_length<wchar_t, boost::long_long_type> : lcast_src_length_integral<boost::long_long_type> { static void check_coverage() {} };
+# 395 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template<class Source>
+        struct lcast_src_length_floating
+        {
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((std::numeric_limits<Source>::max_exponent10 <= 999999L && std::numeric_limits<Source>::min_exponent10 >= -999999L) == 0 ? false : true) >)>
+
+
+ boost_static_assert_typedef_401;
+            static const std::size_t value = 5 + lcast_precision<Source>::value + 6
+
+                 ;
+        };
+
+        template<>
+        struct lcast_src_length<char,float>
+          : lcast_src_length_floating<float>
+        {
+            static void check_coverage() {}
+        };
+
+        template<>
+        struct lcast_src_length<char,double>
+          : lcast_src_length_floating<double>
+        {
+            static void check_coverage() {}
+        };
+
+        template<>
+        struct lcast_src_length<char,long double>
+          : lcast_src_length_floating<long double>
+        {
+            static void check_coverage() {}
+        };
+
+
+    template<>
+    struct lcast_src_length<wchar_t,float>
+      : lcast_src_length_floating<float>
+    {
+        static void check_coverage() {}
+    };
+
+    template<>
+    struct lcast_src_length<wchar_t,double>
+      : lcast_src_length_floating<double>
+    {
+        static void check_coverage() {}
+    };
+
+    template<>
+    struct lcast_src_length<wchar_t,long double>
+      : lcast_src_length_floating<long double>
+    {
+        static void check_coverage() {}
+    };
+
+
+
+    }
+
+    namespace detail
+    {
+        template<typename CharT> struct lcast_char_constants;
+
+        template<>
+        struct lcast_char_constants<char>
+        {
+            static const char zero = '0';
+            static const char minus = '-';
+        };
+
+
+        template<>
+        struct lcast_char_constants<wchar_t>
+        {
+            static const wchar_t zero = L'0';
+            static const wchar_t minus = L'-';
+        };
+
+    }
+
+    namespace detail
+    {
+        struct lexical_streambuf_fake
+        {
+        };
+    }
+
+    namespace detail
+    {
+
+
+
+
+
+
+
+        template<class T>
+        inline
+        typename make_unsigned<T>::type lcast_to_unsigned(T value)
+        {
+            typedef typename make_unsigned<T>::type result_type;
+            result_type uvalue = static_cast<result_type>(value);
+            return value < 0 ? -uvalue : uvalue;
+        }
+
+
+
+
+
+    }
+
+    namespace detail
+    {
+        template<class Traits, class T, class CharT>
+        CharT* lcast_put_unsigned(T n, CharT* finish)
+        {
+
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!std::numeric_limits<T>::is_signed) == 0 ? false : true) >)> boost_static_assert_typedef_512;
+
+
+
+
+            std::locale loc;
+            typedef std::numpunct<CharT> numpunct;
+            numpunct const& np = std::use_facet< numpunct >(loc);
+            std::string const& grouping = np.grouping();
+            std::string::size_type const grouping_size = grouping.size();
+            CharT thousands_sep = grouping_size ? np.thousands_sep() : 0;
+            std::string::size_type group = 0;
+            char last_grp_size = grouping[0] <= 0 ? 127 : grouping[0];
+
+
+
+
+            typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((std::numeric_limits<T>::digits10 < 127) == 0 ? false : true) >)> boost_static_assert_typedef_529;
+
+
+            char left = last_grp_size;
+
+
+            typedef typename Traits::int_type int_type;
+            CharT const czero = lcast_char_constants<CharT>::zero;
+            int_type const zero = Traits::to_int_type(czero);
+
+            do
+            {
+
+                if(left == 0)
+                {
+                    ++group;
+                    if(group < grouping_size)
+                    {
+                        char const grp_size = grouping[group];
+                        last_grp_size = grp_size <= 0 ? 127 : grp_size;
+                    }
+
+                    left = last_grp_size;
+                    --finish;
+                    Traits::assign(*finish, thousands_sep);
+                }
+
+                --left;
+
+
+                --finish;
+                int_type const digit = static_cast<int_type>(n % 10U);
+                Traits::assign(*finish, Traits::to_char_type(zero + digit));
+                n /= 10;
+            } while(n);
+
+            return finish;
+        }
+    }
+
+    namespace detail
+    {
+        template<typename Target, typename Source, typename Traits>
+        class lexical_stream
+        {
+        private:
+            typedef typename widest_char<
+                typename stream_char<Target>::type,
+                typename stream_char<Source>::type>::type char_type;
+
+            typedef Traits traits_type;
+
+        public:
+            lexical_stream(char_type* = 0, char_type* = 0)
+            {
+                stream.unsetf(std::ios::skipws);
+                lcast_set_precision(stream, static_cast<Source*>(0), static_cast<Target*>(0) );
+            }
+            ~lexical_stream()
+            {
+
+
+
+            }
+            bool operator<<(const Source &input)
+            {
+                return !(stream << input).fail();
+            }
+            template<typename InputStreamable>
+            bool operator>>(InputStreamable &output)
+            {
+                return !is_pointer<InputStreamable>::value &&
+                       stream >> output &&
+                       stream.get() ==
+
+
+
+
+
+
+
+                           traits_type::eof();
+
+            }
+# 633 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+            bool operator>>(std::basic_string<char_type,traits_type>& output)
+            {
+                stream.str().swap(output);
+                return true;
+            }
+
+            template<class Alloc>
+            bool operator>>(std::basic_string<char_type,traits_type,Alloc>& out)
+            {
+                std::basic_string<char_type,traits_type> str(stream.str());
+                out.assign(str.begin(), str.end());
+                return true;
+            }
+
+        private:
+
+
+
+
+
+            std::basic_stringstream<char_type,traits_type> stream;
+
+        };
+    }
+
+    namespace detail
+    {
+
+        template< class CharT
+                , class Base
+                , class Traits
+                >
+        class lexical_stream_limited_src : public Base
+        {
+
+
+
+            CharT* start;
+            CharT* finish;
+
+        private:
+
+            static void widen_and_assign(char*p, char ch)
+            {
+                Traits::assign(*p, ch);
+            }
+
+
+            static void widen_and_assign(wchar_t* p, char ch)
+            {
+
+                std::locale loc;
+                wchar_t w = std::use_facet< std::ctype<wchar_t> >(loc).widen(ch);
+                Traits::assign(*p, w);
+            }
+
+            static void widen_and_assign(wchar_t* p, wchar_t ch)
+            {
+                Traits::assign(*p, ch);
+            }
+
+            static void widen_and_assign(char*, wchar_t ch);
+
+
+            template<class OutputStreamable>
+            bool lcast_put(const OutputStreamable& input)
+            {
+                this->setp(start, finish);
+                std::basic_ostream<CharT> stream(static_cast<Base*>(this));
+                lcast_set_precision(stream, static_cast<OutputStreamable*>(0));
+                bool const result = !(stream << input).fail();
+                finish = this->pptr();
+                return result;
+            }
+
+
+            lexical_stream_limited_src(lexical_stream_limited_src const&);
+            void operator=(lexical_stream_limited_src const&);
+
+        public:
+
+            lexical_stream_limited_src(CharT* sta, CharT* fin)
+              : start(sta)
+              , finish(fin)
+            {}
+
+        public:
+
+            template<class Alloc>
+            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str)
+            {
+                start = const_cast<CharT*>(str.data());
+                finish = start + str.length();
+                return true;
+            }
+
+            bool operator<<(bool);
+            bool operator<<(char);
+
+            bool operator<<(wchar_t);
+
+            bool operator<<(CharT const*);
+            bool operator<<(short);
+            bool operator<<(int);
+            bool operator<<(long);
+            bool operator<<(unsigned short);
+            bool operator<<(unsigned int);
+            bool operator<<(unsigned long);
+
+            bool operator<<(boost::ulong_long_type);
+            bool operator<<(boost::long_long_type );
+
+
+
+
+
+
+            bool operator<<(float);
+            bool operator<<(double);
+            bool operator<<(long double);
+
+        public:
+
+
+
+            template<typename InputStreamable>
+            bool operator>>(InputStreamable& output)
+            {
+
+
+
+
+
+                if(is_pointer<InputStreamable>::value)
+                    return false;
+
+                this->setg(start, start, finish);
+                std::basic_istream<CharT> stream(static_cast<Base*>(this));
+                stream.unsetf(std::ios::skipws);
+                lcast_set_precision(stream, static_cast<InputStreamable*>(0));
+
+
+
+                return stream >> output &&
+                    stream.get() ==
+
+
+
+
+
+
+
+                Traits::eof();
+
+            }
+
+            bool operator>>(CharT&);
+# 801 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+            template<class Alloc>
+            bool operator>>(std::basic_string<CharT,Traits,Alloc>& str)
+            {
+                str.assign(start, finish);
+                return true;
+            }
+
+        };
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                bool value)
+        {
+            typedef typename Traits::int_type int_type;
+            CharT const czero = lcast_char_constants<CharT>::zero;
+            int_type const zero = Traits::to_int_type(czero);
+            Traits::assign(*start, Traits::to_char_type(zero + value));
+            finish = start + 1;
+            return true;
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                char ch)
+        {
+            widen_and_assign(start, ch);
+            finish = start + 1;
+            return true;
+        }
+
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                wchar_t ch)
+        {
+            widen_and_assign(start, ch);
+            finish = start + 1;
+            return true;
+        }
+
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                short n)
+        {
+            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
+            if(n < 0)
+            {
+                --start;
+                CharT const minus = lcast_char_constants<CharT>::minus;
+                Traits::assign(*start, minus);
+            }
+            return true;
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                int n)
+        {
+            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
+            if(n < 0)
+            {
+                --start;
+                CharT const minus = lcast_char_constants<CharT>::minus;
+                Traits::assign(*start, minus);
+            }
+            return true;
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                long n)
+        {
+            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
+            if(n < 0)
+            {
+                --start;
+                CharT const minus = lcast_char_constants<CharT>::minus;
+                Traits::assign(*start, minus);
+            }
+            return true;
+        }
+
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                boost::long_long_type n)
+        {
+            start = lcast_put_unsigned<Traits>(lcast_to_unsigned(n), finish);
+            if(n < 0)
+            {
+                --start;
+                CharT const minus = lcast_char_constants<CharT>::minus;
+                Traits::assign(*start, minus);
+            }
+            return true;
+        }
+# 914 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                unsigned short n)
+        {
+            start = lcast_put_unsigned<Traits>(n, finish);
+            return true;
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                unsigned int n)
+        {
+            start = lcast_put_unsigned<Traits>(n, finish);
+            return true;
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                unsigned long n)
+        {
+            start = lcast_put_unsigned<Traits>(n, finish);
+            return true;
+        }
+
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                boost::ulong_long_type n)
+        {
+            start = lcast_put_unsigned<Traits>(n, finish);
+            return true;
+        }
+# 956 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                float val)
+        {
+            return this->lcast_put(val);
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                double val)
+        {
+            return this->lcast_put(val);
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                long double val)
+        {
+            return this->lcast_put(val);
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator<<(
+                CharT const* str)
+        {
+            start = const_cast<CharT*>(str);
+            finish = start + Traits::length(str);
+            return true;
+        }
+
+        template<typename CharT, class Base, class Traits>
+        inline bool lexical_stream_limited_src<CharT,Base,Traits>::operator>>(
+                CharT& output)
+        {
+            bool const ok = (finish - start == 1);
+            if(ok)
+                Traits::assign(output, *start);
+            return ok;
+        }
+# 1015 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+    }
+
+    namespace detail
+    {
+
+        template<class Source>
+        struct lcast_streambuf_for_source
+        {
+            static const bool value = false;
+        };
+
+        template<>
+        struct lcast_streambuf_for_source<float>
+        {
+            static const bool value = true;
+        };
+
+        template<>
+        struct lcast_streambuf_for_source<double>
+        {
+            static const bool value = true;
+        };
+
+        template<>
+        struct lcast_streambuf_for_source<long double>
+        {
+            static const bool value = true;
+        };
+    }
+
+    namespace detail
+    {
+
+        template<class Target>
+        struct lcast_streambuf_for_target
+        {
+            static const bool value = true;
+        };
+
+        template<>
+        struct lcast_streambuf_for_target<char>
+        {
+            static const bool value = false;
+        };
+
+
+        template<>
+        struct lcast_streambuf_for_target<wchar_t>
+        {
+            static const bool value = false;
+        };
+
+
+
+        template<class Traits, class Alloc>
+        struct lcast_streambuf_for_target<
+                    std::basic_string<char,Traits,Alloc> >
+        {
+            static const bool value = false;
+        };
+
+
+        template<class Traits, class Alloc>
+        struct lcast_streambuf_for_target<
+                    std::basic_string<wchar_t,Traits,Alloc> >
+        {
+            static const bool value = false;
+        };
+# 1099 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+    }
+
+
+
+
+
+    namespace detail
+    {
+        template<class T>
+        struct array_to_pointer_decay
+        {
+            typedef T type;
+        };
+
+        template<class T, std::size_t N>
+        struct array_to_pointer_decay<T[N]>
+        {
+            typedef const T * type;
+        };
+
+
+
+
+
+
+
+        template< typename Target
+                , typename Source
+                , bool Unlimited
+                , typename CharT
+                >
+        Target lexical_cast(
+            typename boost::call_traits<Source>::param_type arg,
+            CharT* buf, std::size_t src_len)
+        {
+            typedef typename
+                deduce_char_traits<CharT,Target,Source>::type traits;
+
+            typedef typename boost::mpl::if_c<
+                lcast_streambuf_for_target<Target>::value ||
+                lcast_streambuf_for_source<Source>::value
+              , std::basic_streambuf<CharT>
+              , lexical_streambuf_fake
+              >::type base;
+
+            typename boost::mpl::if_c<
+                Unlimited
+              , detail::lexical_stream<Target,Source,traits>
+              , detail::lexical_stream_limited_src<CharT,base,traits>
+              >::type interpreter(buf, buf + src_len);
+
+            Target result;
+            if(!(interpreter << arg && interpreter >> result))
+                throw_exception(bad_lexical_cast(typeid(Source), typeid(Target)));
+            return result;
+        }
+
+
+
+    }
+
+    template<typename Target, typename Source>
+    inline Target lexical_cast(const Source &arg)
+    {
+        typedef typename detail::array_to_pointer_decay<Source>::type src;
+
+        typedef typename detail::widest_char<
+            typename detail::stream_char<Target>::type
+          , typename detail::stream_char<src>::type
+          >::type char_type;
+
+        typedef detail::lcast_src_length<char_type, src> lcast_src_length;
+        std::size_t const src_len = lcast_src_length::value;
+        char_type buf[src_len + 1];
+        lcast_src_length::check_coverage();
+        return detail::lexical_cast<Target, src, !src_len>(arg, buf, src_len);
+    }
+# 1203 "/usr/include/boost-1_42/boost/lexical_cast.hpp"
+}
+# 20 "/usr/include/boost-1_42/boost/python/operators.hpp" 2
+
+
+
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+  template <class T>
+  PyObject* convert_result(T const& x)
+  {
+      return converter::arg_to_python<T>(x).release();
+  }
+
+
+
+  template <operator_id> struct operator_l
+  {
+      template <class L, class R> struct apply;
+  };
+
+  template <operator_id> struct operator_r
+  {
+      template <class L, class R> struct apply;
+  };
+
+  template <operator_id> struct operator_1
+  {
+      template <class T> struct apply;
+  };
+
+
+
+
+  template <operator_id id, class L, class R>
+  struct operator_l_inner
+      : operator_l<id>::template apply<L,R>
+  {};
+
+  template <operator_id id, class L, class R>
+  struct operator_r_inner
+      : operator_r<id>::template apply<L,R>
+  {};
+
+  template <operator_id id, class T>
+  struct operator_1_inner
+      : operator_1<id>::template apply<T>
+  {};
+# 84 "/usr/include/boost-1_42/boost/python/operators.hpp"
+  template <operator_id id>
+  struct binary_op : operator_l<id>
+  {
+      template <class T>
+      struct apply : operator_l_inner<id,T,T>
+      {
+      };
+  };
+
+
+  template <operator_id id, class R>
+  struct binary_op_l : operator_l<id>
+  {
+      template <class T>
+      struct apply : operator_l_inner<id,T,R>
+      {
+      };
+  };
+
+
+  template <operator_id id, class L>
+  struct binary_op_r : operator_r<id>
+  {
+      template <class T>
+      struct apply : operator_r_inner<id,L,T>
+      {
+      };
+  };
+
+  template <operator_id id>
+  struct unary_op : operator_1<id>
+  {
+      template <class T>
+      struct apply : operator_1_inner<id,T>
+      {
+      };
+  };
+
+
+
+  template <operator_id id, class L = not_specified, class R = not_specified>
+  struct operator_
+    : def_visitor<operator_<id,L,R> >
+  {
+   private:
+      template <class ClassT>
+      void visit(ClassT& cl) const
+      {
+          typedef typename mpl::eval_if<
+              is_same<L,self_t>
+            , mpl::if_<
+                  is_same<R,self_t>
+                , binary_op<id>
+                , binary_op_l<
+                      id
+                    , typename unwrap_other<R>::type
+                  >
+              >
+            , mpl::if_<
+                  is_same<L,not_specified>
+                , unary_op<id>
+                , binary_op_r<
+                      id
+                    , typename unwrap_other<L>::type
+                  >
+              >
+          >::type generator;
+
+          cl.def(
+              generator::name()
+            , &generator::template apply<
+                 typename ClassT::wrapped_type
+              >::execute
+          );
+      }
+
+      friend class python::def_visitor_access;
+  };
+}
+# 212 "/usr/include/boost-1_42/boost/python/operators.hpp"
+namespace detail { template <> struct operator_l<op_add> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l + r); } }; static char const* name() { return "__" "add" "__"; } }; template <> struct operator_r<op_add> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l + r); } }; static char const* name() { return "__" "radd" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_add,L,R> operator +(L const&, R const&) { return detail::operator_<detail::op_add,L,R>(); } }
+namespace detail { template <> struct operator_l<op_sub> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l - r); } }; static char const* name() { return "__" "sub" "__"; } }; template <> struct operator_r<op_sub> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l - r); } }; static char const* name() { return "__" "rsub" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_sub,L,R> operator -(L const&, R const&) { return detail::operator_<detail::op_sub,L,R>(); } }
+namespace detail { template <> struct operator_l<op_mul> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l * r); } }; static char const* name() { return "__" "mul" "__"; } }; template <> struct operator_r<op_mul> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l * r); } }; static char const* name() { return "__" "rmul" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_mul,L,R> operator *(L const&, R const&) { return detail::operator_<detail::op_mul,L,R>(); } }
+namespace detail { template <> struct operator_l<op_div> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l / r); } }; static char const* name() { return "__" "div" "__"; } }; template <> struct operator_r<op_div> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l / r); } }; static char const* name() { return "__" "rdiv" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_div,L,R> operator /(L const&, R const&) { return detail::operator_<detail::op_div,L,R>(); } }
+namespace detail { template <> struct operator_l<op_mod> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l % r); } }; static char const* name() { return "__" "mod" "__"; } }; template <> struct operator_r<op_mod> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l % r); } }; static char const* name() { return "__" "rmod" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_mod,L,R> operator %(L const&, R const&) { return detail::operator_<detail::op_mod,L,R>(); } }
+namespace detail { template <> struct operator_l<op_lshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l << r); } }; static char const* name() { return "__" "lshift" "__"; } }; template <> struct operator_r<op_lshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l << r); } }; static char const* name() { return "__" "rlshift" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_lshift,L,R> operator <<(L const&, R const&) { return detail::operator_<detail::op_lshift,L,R>(); } }
+namespace detail { template <> struct operator_l<op_rshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l >> r); } }; static char const* name() { return "__" "rshift" "__"; } }; template <> struct operator_r<op_rshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l >> r); } }; static char const* name() { return "__" "rrshift" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_rshift,L,R> operator >>(L const&, R const&) { return detail::operator_<detail::op_rshift,L,R>(); } }
+namespace detail { template <> struct operator_l<op_and> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l & r); } }; static char const* name() { return "__" "and" "__"; } }; template <> struct operator_r<op_and> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l & r); } }; static char const* name() { return "__" "rand" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_and,L,R> operator &(L const&, R const&) { return detail::operator_<detail::op_and,L,R>(); } }
+namespace detail { template <> struct operator_l<op_xor> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l ^ r); } }; static char const* name() { return "__" "xor" "__"; } }; template <> struct operator_r<op_xor> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l ^ r); } }; static char const* name() { return "__" "rxor" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_xor,L,R> operator ^(L const&, R const&) { return detail::operator_<detail::op_xor,L,R>(); } }
+namespace detail { template <> struct operator_l<op_or> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l | r); } }; static char const* name() { return "__" "or" "__"; } }; template <> struct operator_r<op_or> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l | r); } }; static char const* name() { return "__" "ror" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_or,L,R> operator |(L const&, R const&) { return detail::operator_<detail::op_or,L,R>(); } }
+namespace detail { template <> struct operator_l<op_gt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l > r); } }; static char const* name() { return "__" "gt" "__"; } }; template <> struct operator_r<op_gt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l > r); } }; static char const* name() { return "__" "lt" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_gt,L,R> operator >(L const&, R const&) { return detail::operator_<detail::op_gt,L,R>(); } }
+namespace detail { template <> struct operator_l<op_ge> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l >= r); } }; static char const* name() { return "__" "ge" "__"; } }; template <> struct operator_r<op_ge> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l >= r); } }; static char const* name() { return "__" "le" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_ge,L,R> operator >=(L const&, R const&) { return detail::operator_<detail::op_ge,L,R>(); } }
+namespace detail { template <> struct operator_l<op_lt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l < r); } }; static char const* name() { return "__" "lt" "__"; } }; template <> struct operator_r<op_lt> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l < r); } }; static char const* name() { return "__" "gt" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_lt,L,R> operator <(L const&, R const&) { return detail::operator_<detail::op_lt,L,R>(); } }
+namespace detail { template <> struct operator_l<op_le> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l <= r); } }; static char const* name() { return "__" "le" "__"; } }; template <> struct operator_r<op_le> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l <= r); } }; static char const* name() { return "__" "ge" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_le,L,R> operator <=(L const&, R const&) { return detail::operator_<detail::op_le,L,R>(); } }
+namespace detail { template <> struct operator_l<op_eq> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l == r); } }; static char const* name() { return "__" "eq" "__"; } }; template <> struct operator_r<op_eq> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l == r); } }; static char const* name() { return "__" "eq" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_eq,L,R> operator ==(L const&, R const&) { return detail::operator_<detail::op_eq,L,R>(); } }
+namespace detail { template <> struct operator_l<op_ne> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(l != r); } }; static char const* name() { return "__" "ne" "__"; } }; template <> struct operator_r<op_ne> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(l != r); } }; static char const* name() { return "__" "ne" "__"; } }; } namespace self_ns { template <class L, class R> inline detail::operator_<detail::op_ne,L,R> operator !=(L const&, R const&) { return detail::operator_<detail::op_ne,L,R>(); } }
+
+
+
+namespace detail { template <> struct operator_l<op_pow> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(lhs& l, rhs const& r) { return detail::convert_result(pow(l,r)); } }; static char const* name() { return "__" "pow" "__"; } }; template <> struct operator_r<op_pow> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(rhs& r, lhs const& l) { return detail::convert_result(pow(l,r)); } }; static char const* name() { return "__" "rpow" "__"; } }; }
+
+
+namespace self_ns
+{
+
+  template <class L, class R>
+  inline detail::operator_<detail::op_pow,L,R>
+  pow(L const&, R const&)
+  {
+      return detail::operator_<detail::op_pow,L,R>();
+  }
+# 267 "/usr/include/boost-1_42/boost/python/operators.hpp"
+}
+# 301 "/usr/include/boost-1_42/boost/python/operators.hpp"
+namespace detail { template <> struct operator_l<op_iadd> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() += r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "iadd" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_iadd,self_t,R> operator +=(self_t const&, R const&) { return detail::operator_<detail::op_iadd,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_isub> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() -= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "isub" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_isub,self_t,R> operator -=(self_t const&, R const&) { return detail::operator_<detail::op_isub,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_imul> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() *= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "imul" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_imul,self_t,R> operator *=(self_t const&, R const&) { return detail::operator_<detail::op_imul,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_idiv> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() /= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "idiv" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_idiv,self_t,R> operator /=(self_t const&, R const&) { return detail::operator_<detail::op_idiv,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_imod> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() %= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "imod" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_imod,self_t,R> operator %=(self_t const&, R const&) { return detail::operator_<detail::op_imod,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_ilshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() <<= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "ilshift" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_ilshift,self_t,R> operator <<=(self_t const&, R const&) { return detail::operator_<detail::op_ilshift,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_irshift> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() >>= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "irshift" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_irshift,self_t,R> operator >>=(self_t const&, R const&) { return detail::operator_<detail::op_irshift,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_iand> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() &= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "iand" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_iand,self_t,R> operator &=(self_t const&, R const&) { return detail::operator_<detail::op_iand,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_ixor> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() ^= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "ixor" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_ixor,self_t,R> operator ^=(self_t const&, R const&) { return detail::operator_<detail::op_ixor,self_t,R>(); } }
+namespace detail { template <> struct operator_l<op_ior> { template <class L, class R> struct apply { typedef typename unwrap_wrapper_<L>::type lhs; typedef typename unwrap_wrapper_<R>::type rhs; static PyObject* execute(back_reference<lhs&> l, rhs const& r) { l.get() |= r; return python::incref(l.source().ptr()); } }; static char const* name() { return "__" "ior" "__"; } }; } namespace self_ns { template <class R> inline detail::operator_<detail::op_ior,self_t,R> operator |=(self_t const&, R const&) { return detail::operator_<detail::op_ior,self_t,R>(); } }
+# 340 "/usr/include/boost-1_42/boost/python/operators.hpp"
+namespace detail { template <> struct operator_1<op_neg> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(-(x)); } }; static char const* name() { return "__" "neg" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_neg> operator-(self_t const&) { return detail::operator_<detail::op_neg>(); } }
+namespace detail { template <> struct operator_1<op_pos> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(+(x)); } }; static char const* name() { return "__" "pos" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_pos> operator+(self_t const&) { return detail::operator_<detail::op_pos>(); } }
+namespace detail { template <> struct operator_1<op_abs> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(abs(x)); } }; static char const* name() { return "__" "abs" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_abs> abs(self_t const&) { return detail::operator_<detail::op_abs>(); } }
+namespace detail { template <> struct operator_1<op_invert> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(~(x)); } }; static char const* name() { return "__" "invert" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_invert> operator~(self_t const&) { return detail::operator_<detail::op_invert>(); } }
+
+
+
+namespace detail { template <> struct operator_1<op_nonzero> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(!!(x)); } }; static char const* name() { return "__" "nonzero" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_nonzero> operator!(self_t const&) { return detail::operator_<detail::op_nonzero>(); } }
+
+namespace detail { template <> struct operator_1<op_int> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(long(x)); } }; static char const* name() { return "__" "int" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_int> int_(self_t const&) { return detail::operator_<detail::op_int>(); } }
+namespace detail { template <> struct operator_1<op_long> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(PyLong_FromLong(x)); } }; static char const* name() { return "__" "long" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_long> long_(self_t const&) { return detail::operator_<detail::op_long>(); } }
+namespace detail { template <> struct operator_1<op_float> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(double(x)); } }; static char const* name() { return "__" "float" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_float> float_(self_t const&) { return detail::operator_<detail::op_float>(); } }
+namespace detail { template <> struct operator_1<op_complex> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(std::complex<double>(x)); } }; static char const* name() { return "__" "complex" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_complex> complex_(self_t const&) { return detail::operator_<detail::op_complex>(); } }
+namespace detail { template <> struct operator_1<op_str> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(lexical_cast<std::string>(x)); } }; static char const* name() { return "__" "str" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_str> str(self_t const&) { return detail::operator_<detail::op_str>(); } }
+namespace detail { template <> struct operator_1<op_repr> { template <class T> struct apply { typedef typename unwrap_wrapper_<T>::type self_t; static PyObject* execute(self_t& x) { return detail::convert_result(lexical_cast<std::string>(x)); } }; static char const* name() { return "__" "repr" "__"; } }; } namespace self_ns { inline detail::operator_<detail::op_repr> repr(self_t const&) { return detail::operator_<detail::op_repr>(); } }
+
+
+}}
+# 51 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/overloads.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/overloads.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/repeat_from_to.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/reverse.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/tuple/to_seq.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/preprocessor/tuple.hpp" 2
+# 19 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 2
+# 29 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 30 "/usr/include/boost-1_42/boost/python/detail/defaults_gen.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+  struct overloads_base
+  {
+      overloads_base(char const* doc_)
+          : m_doc(doc_) {}
+
+      overloads_base(char const* doc_, detail::keyword_range const& kw)
+          : m_doc(doc_), m_keywords(kw) {}
+
+      char const* doc_string() const
+      {
+          return m_doc;
+      }
+
+      detail::keyword_range const& keywords() const
+      {
+          return m_keywords;
+      }
+
+   private:
+      char const* m_doc;
+      detail::keyword_range m_keywords;
+  };
+
+
+
+  template <class CallPoliciesT, class OverloadsT>
+  struct overloads_proxy
+      : public overloads_base
+  {
+      typedef typename OverloadsT::non_void_return_type non_void_return_type;
+      typedef typename OverloadsT::void_return_type void_return_type;
+
+      overloads_proxy(
+          CallPoliciesT const& policies_
+          , char const* doc
+          , keyword_range const& kw
+          )
+          : overloads_base(doc, kw)
+            , policies(policies_)
+      {}
+
+      CallPoliciesT
+      call_policies() const
+      {
+          return policies;
+      }
+
+      CallPoliciesT policies;
+  };
+
+
+
+
+
+  template <class DerivedT>
+  struct overloads_common
+      : public overloads_base
+  {
+      overloads_common(char const* doc)
+          : overloads_base(doc) {}
+
+      overloads_common(char const* doc, keyword_range const& kw)
+          : overloads_base(doc, kw) {}
+
+      default_call_policies
+      call_policies() const
+      {
+          return default_call_policies();
+      }
+
+      template <class CallPoliciesT>
+      overloads_proxy<CallPoliciesT, DerivedT>
+      operator[](CallPoliciesT const& policies) const
+      {
+          return overloads_proxy<CallPoliciesT, DerivedT>(
+              policies, this->doc_string(), this->keywords());
+      }
+  };
+
+}}}
+# 15 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/type_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp" 2
+
+namespace boost {
+
+template< typename T > struct has_nothrow_destructor : ::boost::integral_constant<bool,::boost::has_trivial_destructor<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/type_traits/has_nothrow_destructor.hpp" 2
+# 23 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp" 2
+
+namespace boost {
+
+template< typename T > struct has_virtual_destructor : ::boost::integral_constant<bool,__has_virtual_destructor(T)> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/type_traits/has_virtual_destructor.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp" 2
+
+namespace boost {
+
+   namespace detail{
+      template <class B, class D>
+      struct is_base_of_imp
+      {
+          typedef typename remove_cv<B>::type ncvB;
+          typedef typename remove_cv<D>::type ncvD;
+          static const bool value = (::boost::type_traits::ice_or< (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value), (::boost::type_traits::ice_and< ::boost::is_same<ncvB,ncvD>::value, ::boost::is_class<ncvB>::value>::value)>::value)
+
+                                                                                                                                 ;
+      };
+   }
+
+template< typename Base, typename Derived > struct is_base_of : ::boost::integral_constant<bool,(::boost::detail::is_base_of_imp<Base, Derived>::value)> { };
+
+
+
+
+
+
+template< typename Base, typename Derived > struct is_base_of< Base&,Derived > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_of< Base,Derived& > : ::boost::integral_constant<bool,false> { };
+template< typename Base, typename Derived > struct is_base_of< Base&,Derived& > : ::boost::integral_constant<bool,false> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 50 "/usr/include/boost-1_42/boost/type_traits/is_base_of.hpp" 2
+# 35 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp" 2
+
+namespace boost {
+
+
+template< typename T > struct is_floating_point : ::boost::integral_constant<bool,false> { };
+template<> struct is_floating_point< float > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< float const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_floating_point< double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< double const volatile > : ::boost::integral_constant<bool,true> { };
+template<> struct is_floating_point< long double > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double volatile > : ::boost::integral_constant<bool,true> { }; template<> struct is_floating_point< long double const volatile > : ::boost::integral_constant<bool,true> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/type_traits/is_floating_point.hpp" 2
+# 43 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp" 2
+
+namespace boost {
+
+namespace detail{
+
+template <typename T>
+struct is_member_object_pointer_impl
+{
+   static const bool value = (::boost::type_traits::ice_and< ::boost::is_member_pointer<T>::value, ::boost::type_traits::ice_not< ::boost::is_member_function_pointer<T>::value >::value >::value )
+
+
+
+
+
+                 ;
+};
+
+}
+
+template< typename T > struct is_member_object_pointer : ::boost::integral_constant<bool,::boost::detail::is_member_object_pointer_impl<T>::value> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 45 "/usr/include/boost-1_42/boost/type_traits/is_member_object_pointer.hpp" 2
+# 48 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 60 "/usr/include/boost-1_42/boost/type_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/rank.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/rank.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 20 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/rank.hpp" 2
+
+namespace boost {
+
+
+
+namespace detail{
+
+template <class T, std::size_t N>
+struct rank_imp
+{
+   static const std::size_t value = N;
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T[R], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T const[R], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T volatile[R], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct rank_imp<T const volatile[R], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+
+template <class T, std::size_t N>
+struct rank_imp<T[], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+template <class T, std::size_t N>
+struct rank_imp<T const[], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+template <class T, std::size_t N>
+struct rank_imp<T volatile[], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+template <class T, std::size_t N>
+struct rank_imp<T const volatile[], N>
+{
+   static const std::size_t value = (::boost::detail::rank_imp<T, N+1>::value);
+};
+
+
+}
+
+
+
+
+
+
+template< typename T > struct rank : ::boost::integral_constant<std::size_t,(::boost::detail::rank_imp<T,0>::value)> { };
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_undef.hpp" 1
+# 88 "/usr/include/boost-1_42/boost/type_traits/rank.hpp" 2
+# 61 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/extent.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/extent.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 20 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_def.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/extent.hpp" 2
+
+namespace boost {
+
+namespace detail{
+# 29 "/usr/include/boost-1_42/boost/type_traits/extent.hpp"
+template <class T, std::size_t N>
+struct extent_imp
+{
+   static const std::size_t value = 0;
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T volatile[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R, std::size_t N>
+struct extent_imp<T const volatile[R], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T[R],0>
+{
+   static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const[R], 0>
+{
+   static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T volatile[R], 0>
+{
+   static const std::size_t value = R;
+};
+
+template <class T, std::size_t R>
+struct extent_imp<T const volatile[R], 0>
+{
+   static const std::size_t value = R;
+};
+
+
+template <class T, std::size_t N>
+struct extent_imp<T[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T const[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T volatile[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T, std::size_t N>
+struct extent_imp<T const volatile[], N>
+{
+   static const std::size_t value = (::boost::detail::extent_imp<T, N-1>::value);
+};
+template <class T>
+struct extent_imp<T[], 0>
+{
+   static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T const[], 0>
+{
+   static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T volatile[], 0>
+{
+   static const std::size_t value = 0;
+};
+template <class T>
+struct extent_imp<T const volatile[], 0>
+{
+   static const std::size_t value = 0;
+};
+
+
+
+
+}
+
+template <class T, std::size_t N = 0>
+struct extent
+   : public ::boost::integral_constant<std::size_t, ::boost::detail::extent_imp<T,N>::value>
+{
+
+
+
+
+   
+};
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/size_t_trait_undef.hpp" 1
+# 144 "/usr/include/boost-1_42/boost/type_traits/extent.hpp" 2
+# 62 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 15 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 2
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 2
+
+
+
+namespace boost {
+
+template< typename T > struct remove_extent { typedef T type; };
+
+
+template< typename T, std::size_t N > struct remove_extent<T[N]> { typedef T type; };
+template< typename T, std::size_t N > struct remove_extent<T const[N]> { typedef T const type; };
+template< typename T, std::size_t N > struct remove_extent<T volatile[N]> { typedef T volatile type; };
+template< typename T, std::size_t N > struct remove_extent<T const volatile[N]> { typedef T const volatile type; };
+
+template< typename T > struct remove_extent<T[]> { typedef T type; };
+template< typename T > struct remove_extent<T const[]> { typedef T const type; };
+template< typename T > struct remove_extent<T volatile[]> { typedef T volatile type; };
+template< typename T > struct remove_extent<T const volatile[]> { typedef T const volatile type; };
+
+
+
+}
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/type_traits/remove_extent.hpp" 2
+# 64 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 14 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 2
+
+
+
+namespace boost {
+
+template< typename T > struct remove_all_extents { typedef T type; };
+
+
+template< typename T, std::size_t N > struct remove_all_extents<T[N]> { typedef typename boost::remove_all_extents<T>::type type; };
+template< typename T, std::size_t N > struct remove_all_extents<T const[N]> { typedef typename boost::remove_all_extents<T const>::type type; };
+template< typename T, std::size_t N > struct remove_all_extents<T volatile[N]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
+template< typename T, std::size_t N > struct remove_all_extents<T const volatile[N]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };
+
+template< typename T > struct remove_all_extents<T[]> { typedef typename boost::remove_all_extents<T>::type type; };
+template< typename T > struct remove_all_extents<T const[]> { typedef typename boost::remove_all_extents<T const>::type type; };
+template< typename T > struct remove_all_extents<T volatile[]> { typedef typename boost::remove_all_extents<T volatile>::type type; };
+template< typename T > struct remove_all_extents<T const volatile[]> { typedef typename boost::remove_all_extents<T const volatile>::type type; };
+
+
+
+}
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 47 "/usr/include/boost-1_42/boost/type_traits/remove_all_extents.hpp" 2
+# 65 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/aligned_storage.hpp" 1
+# 73 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 22 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp" 2
+
+namespace boost {
+
+namespace type_traits { namespace detail {
+
+
+
+template<class T>
+struct floating_point_promotion
+{
+    typedef T type;
+};
+
+template<>
+struct floating_point_promotion<float>
+{
+    typedef double type;
+};
+
+template<>
+struct floating_point_promotion<float const>
+{
+    typedef double const type;
+};
+
+template<>
+struct floating_point_promotion<float volatile>
+{
+    typedef double volatile type;
+};
+
+template<>
+struct floating_point_promotion<float const volatile>
+{
+    typedef double const volatile type;
+};
+# 78 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp"
+} }
+
+template< typename T > struct floating_point_promotion { typedef typename boost::type_traits::detail::floating_point_promotion<T>::type type; };
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 89 "/usr/include/boost-1_42/boost/type_traits/floating_point_promotion.hpp" 2
+# 74 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 21 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp" 2
+
+namespace boost {
+
+namespace type_traits { namespace detail {
+
+
+template <class T> struct need_promotion : boost::is_enum<T> {};
+
+
+template<> struct need_promotion<char > : true_type {};
+template<> struct need_promotion<signed char > : true_type {};
+template<> struct need_promotion<unsigned char > : true_type {};
+template<> struct need_promotion<signed short int > : true_type {};
+template<> struct need_promotion<unsigned short int> : true_type {};
+# 63 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+template<> struct need_promotion<boost::ulong_long_type> : integral_constant<bool, (sizeof(boost::ulong_long_type) < sizeof(int))> {};
+template<> struct need_promotion<boost::long_long_type> : integral_constant<bool, (sizeof(boost::long_long_type) < sizeof(int))> {};
+# 75 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+template<> struct need_promotion<wchar_t> : true_type {};
+
+
+
+
+
+template<> struct need_promotion<bool> : true_type {};
+
+
+
+
+template<int Index, int IsConst, int IsVolatile> struct promote_from_index;
+# 95 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+template<> struct promote_from_index<1,0,0> { typedef int type; }; template<> struct promote_from_index<1,0,1> { typedef int volatile type; }; template<> struct promote_from_index<1,1,0> { typedef int const type; }; template<> struct promote_from_index<1,1,1> { typedef int const volatile type; };
+template<> struct promote_from_index<2,0,0> { typedef unsigned int type; }; template<> struct promote_from_index<2,0,1> { typedef unsigned int volatile type; }; template<> struct promote_from_index<2,1,0> { typedef unsigned int const type; }; template<> struct promote_from_index<2,1,1> { typedef unsigned int const volatile type; };
+template<> struct promote_from_index<3,0,0> { typedef long type; }; template<> struct promote_from_index<3,0,1> { typedef long volatile type; }; template<> struct promote_from_index<3,1,0> { typedef long const type; }; template<> struct promote_from_index<3,1,1> { typedef long const volatile type; };
+template<> struct promote_from_index<4,0,0> { typedef unsigned long type; }; template<> struct promote_from_index<4,0,1> { typedef unsigned long volatile type; }; template<> struct promote_from_index<4,1,0> { typedef unsigned long const type; }; template<> struct promote_from_index<4,1,1> { typedef unsigned long const volatile type; };
+# 107 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+template<> struct promote_from_index<5,0,0> { typedef boost::long_long_type type; }; template<> struct promote_from_index<5,0,1> { typedef boost::long_long_type volatile type; }; template<> struct promote_from_index<5,1,0> { typedef boost::long_long_type const type; }; template<> struct promote_from_index<5,1,1> { typedef boost::long_long_type const volatile type; };
+template<> struct promote_from_index<6,0,0> { typedef boost::ulong_long_type type; }; template<> struct promote_from_index<6,0,1> { typedef boost::ulong_long_type volatile type; }; template<> struct promote_from_index<6,1,0> { typedef boost::ulong_long_type const type; }; template<> struct promote_from_index<6,1,1> { typedef boost::ulong_long_type const volatile type; };
+# 120 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+template<int N>
+struct sized_type_for_promotion
+{
+    typedef char (&type)[N];
+};
+# 136 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+sized_type_for_promotion<1>::type promoted_index_tester(int);
+sized_type_for_promotion<2>::type promoted_index_tester(unsigned int);
+sized_type_for_promotion<3>::type promoted_index_tester(long);
+sized_type_for_promotion<4>::type promoted_index_tester(unsigned long);
+
+
+sized_type_for_promotion<5>::type promoted_index_tester(boost::long_long_type);
+sized_type_for_promotion<6>::type promoted_index_tester(boost::ulong_long_type);
+# 154 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp"
+template<class T>
+struct promoted_index
+{
+    static T testee;
+    static const int value = sizeof(promoted_index_tester(+testee));
+
+};
+
+template<class T>
+struct integral_promotion_impl
+{
+    typedef typename promote_from_index<
+        (boost::type_traits::detail::promoted_index<T>::value)
+      , (boost::is_const<T>::value)
+      , (boost::is_volatile<T>::value)
+      >::type type;
+};
+
+template<class T>
+struct integral_promotion
+  : boost::mpl::eval_if<
+        need_promotion<typename remove_cv<T>::type>
+      , integral_promotion_impl<T>
+      , boost::mpl::identity<T>
+      >
+{
+};
+
+} }
+
+template< typename T > struct integral_promotion { typedef typename boost::type_traits::detail::integral_promotion<T>::type type; };
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 193 "/usr/include/boost-1_42/boost/type_traits/integral_promotion.hpp" 2
+# 76 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/promote.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/promote.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/promote.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template<class T>
+struct promote_impl
+  : integral_promotion<
+        typename floating_point_promotion<T>::type
+      >
+{
+};
+
+}
+
+template< typename T > struct promote { typedef typename boost::detail::promote_impl<T>::type type; };
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 38 "/usr/include/boost-1_42/boost/type_traits/promote.hpp" 2
+# 77 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp" 1
+# 29 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_def.hpp" 2
+# 30 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp" 2
+
+namespace boost {
+
+namespace detail {
+
+template <class T>
+struct make_signed_imp
+{
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_enum<T>::value>::value)) == 0 ? false : true) >)>
+ boost_static_assert_typedef_39;
+
+   typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((::boost::type_traits::ice_not< ::boost::is_same< typename remove_cv<T>::type, bool>::value>::value)) == 0 ? false : true) >)>
+
+ boost_static_assert_typedef_43;
+
+
+   typedef typename remove_cv<T>::type t_no_cv;
+   typedef typename mpl::if_c<
+      (::boost::type_traits::ice_and<
+         ::boost::is_signed<T>::value,
+         ::boost::is_integral<T>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+         ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value >::value),
+      T,
+      typename mpl::if_c<
+         (::boost::type_traits::ice_and<
+            ::boost::is_integral<T>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, char>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, wchar_t>::value>::value,
+            ::boost::type_traits::ice_not< ::boost::is_same<t_no_cv, bool>::value>::value>
+         ::value),
+         typename mpl::if_<
+            is_same<t_no_cv, unsigned char>,
+            signed char,
+            typename mpl::if_<
+               is_same<t_no_cv, unsigned short>,
+               signed short,
+               typename mpl::if_<
+                  is_same<t_no_cv, unsigned int>,
+                  int,
+                  typename mpl::if_<
+                     is_same<t_no_cv, unsigned long>,
+                     long,
+
+                     boost::long_long_type
+
+
+
+
+
+                  >::type
+               >::type
+            >::type
+         >::type,
+
+         typename mpl::if_c<
+            sizeof(t_no_cv) == sizeof(unsigned char),
+            signed char,
+            typename mpl::if_c<
+               sizeof(t_no_cv) == sizeof(unsigned short),
+               signed short,
+               typename mpl::if_c<
+                  sizeof(t_no_cv) == sizeof(unsigned int),
+                  int,
+                  typename mpl::if_c<
+                     sizeof(t_no_cv) == sizeof(unsigned long),
+                     long,
+
+                     boost::long_long_type
+
+
+
+
+
+                  >::type
+               >::type
+            >::type
+         >::type
+      >::type
+   >::type base_integer_type;
+
+
+   typedef typename mpl::if_<
+      is_const<T>,
+      typename add_const<base_integer_type>::type,
+      base_integer_type
+   >::type const_base_integer_type;
+
+
+   typedef typename mpl::if_<
+      is_volatile<T>,
+      typename add_volatile<const_base_integer_type>::type,
+      const_base_integer_type
+   >::type type;
+};
+
+
+}
+
+template< typename T > struct make_signed { typedef typename boost::detail::make_signed_imp<T>::type type; };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/type_trait_undef.hpp" 1
+# 135 "/usr/include/boost-1_42/boost/type_traits/make_signed.hpp" 2
+# 80 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/decay.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/type_traits/decay.hpp"
+namespace boost
+{
+
+    template< class T >
+    struct decay
+    {
+    private:
+        typedef typename remove_reference<T>::type Ty;
+    public:
+        typedef typename mpl::eval_if<
+            is_array<Ty>,
+            mpl::identity<typename remove_bounds<Ty>::type*>,
+            typename mpl::eval_if<
+                is_function<Ty>,
+                add_pointer<Ty>,
+                mpl::identity<Ty>
+            >
+        >::type type;
+    };
+
+}
+# 81 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp"
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/template_arity_spec.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_def.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp" 2
+
+
+namespace boost {
+namespace detail{
+
+struct is_convertible_from_tester
+{
+   template <class T>
+   is_convertible_from_tester(const std::complex<T>&);
+};
+
+}
+
+template< typename T > struct is_complex : ::boost::integral_constant<bool,(::boost::is_convertible<T, detail::is_convertible_from_tester>::value)> { };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/type_traits/detail/bool_trait_undef.hpp" 1
+# 33 "/usr/include/boost-1_42/boost/type_traits/is_complex.hpp" 2
+# 82 "/usr/include/boost-1_42/boost/type_traits.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+namespace boost { namespace python {
+
+struct module;
+
+namespace objects
+{
+  struct class_base;
+}
+
+namespace detail
+{
+
+
+
+
+
+
+
+  template <class Func, class CallPolicies, class NameSpaceT>
+  static void name_space_def(
+      NameSpaceT& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw
+      , CallPolicies const& policies
+      , char const* doc
+      , objects::class_base*
+      )
+  {
+      typedef typename NameSpaceT::wrapped_type wrapped_type;
+
+      objects::add_to_namespace(
+          name_space, name,
+          detail::make_keyword_range_function(
+              f, policies, kw, get_signature(f, (wrapped_type*)0))
+        , doc
+      );
+  }
+
+  template <class Func, class CallPolicies>
+  static void name_space_def(
+      object& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw
+      , CallPolicies const& policies
+      , char const* doc
+      , ...
+      )
+  {
+      scope within(name_space);
+
+      detail::scope_setattr_doc(
+          name
+          , detail::make_keyword_range_function(f, policies, kw)
+          , doc);
+  }
+
+
+  template <class Func, class CallPolicies, class NameSpaceT>
+  static void name_space_def(
+      NameSpaceT& name_space
+      , char const* name
+      , Func f
+      , keyword_range const& kw
+      , CallPolicies const& policies
+      , char const* doc
+      , module*
+      )
+  {
+      name_space.def(name, f, policies, doc);
+  }
+# 125 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+  template <int N>
+  struct define_stub_function {};
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/lower1.hpp" 2
+# 25 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/slot/detail/shared.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/bounds/upper1.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 47 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<0> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_0
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 48 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<1> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_1
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 53 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<2> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_2
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 58 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<3> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_3
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 63 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<4> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_4
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 68 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<5> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_5
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 73 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<6> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_6
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 78 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<7> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_7
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 83 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<8> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_8
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 88 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<9> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_9
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 93 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<10> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_10
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 98 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<11> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_11
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 103 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<12> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_12
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 108 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<13> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_13
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 113 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<14> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_14
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 118 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 1
+# 269 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+template <>
+struct define_stub_function<15> {
+    template <class StubsT, class CallPolicies, class NameSpaceT>
+    static void define(
+        char const* name
+        , StubsT const&
+        , keyword_range const& kw
+        , CallPolicies const& policies
+        , NameSpaceT& name_space
+        , char const* doc)
+    {
+        detail::name_space_def(
+            name_space
+            , name
+            , &StubsT::func_15
+            , kw
+            , policies
+            , doc
+            , &name_space);
+    }
+};
+# 123 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/iter/forward1.hpp" 2
+# 132 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp" 2
+# 157 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+  template <int N>
+  struct define_with_defaults_helper {
+
+      template <class StubsT, class CallPolicies, class NameSpaceT>
+      static void
+      def(
+          char const* name,
+          StubsT stubs,
+          keyword_range kw,
+          CallPolicies const& policies,
+          NameSpaceT& name_space,
+          char const* doc)
+      {
+
+          define_stub_function<N>::define(name, stubs, kw, policies, name_space, doc);
+
+          if (kw.second > kw.first)
+              --kw.second;
+
+
+          define_with_defaults_helper<N-1>::def(name, stubs, kw, policies, name_space, doc);
+      }
+  };
+
+  template <>
+  struct define_with_defaults_helper<0> {
+
+      template <class StubsT, class CallPolicies, class NameSpaceT>
+      static void
+      def(
+          char const* name,
+          StubsT stubs,
+          keyword_range const& kw,
+          CallPolicies const& policies,
+          NameSpaceT& name_space,
+          char const* doc)
+      {
+
+          define_stub_function<0>::define(name, stubs, kw, policies, name_space, doc);
+
+      }
+  };
+# 228 "/usr/include/boost-1_42/boost/python/detail/defaults_def.hpp"
+  template <class OverloadsT, class NameSpaceT, class SigT>
+  inline void
+  define_with_defaults(
+      char const* name,
+      OverloadsT const& overloads,
+      NameSpaceT& name_space,
+      SigT const&)
+  {
+      typedef typename mpl::front<SigT>::type return_type;
+      typedef typename OverloadsT::void_return_type void_return_type;
+      typedef typename OverloadsT::non_void_return_type non_void_return_type;
+
+      typedef typename mpl::if_c<
+          boost::is_same<void, return_type>::value
+          , void_return_type
+          , non_void_return_type
+      >::type stubs_type;
+
+      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((stubs_type::max_args) <= mpl::size<SigT>::value) == 0 ? false : true) >)>
+ boost_static_assert_typedef_247;
+
+      typedef typename stubs_type::template gen<SigT> gen_type;
+      define_with_defaults_helper<stubs_type::n_funcs-1>::def(
+          name
+          , gen_type()
+          , overloads.keywords()
+          , overloads.call_policies()
+          , name_space
+          , overloads.doc_string());
+  }
+
+}
+
+}}
+# 12 "/usr/include/boost-1_42/boost/python/overloads.hpp" 2
+# 53 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp"
+namespace boost { namespace python { namespace detail {
+
+
+
+
+template <class NullaryFunction>
+struct nullary_function_adaptor
+{
+    nullary_function_adaptor(NullaryFunction fn)
+      : m_fn(fn)
+    {}
+
+    void operator()() const { m_fn(); }
+# 38 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp"
+# 1 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/preprocessor/iteration/detail/local.hpp"
+        template < class A0> void operator()( A0 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1> void operator()( A0 const& , A1 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2> void operator()( A0 const& , A1 const& , A2 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3> void operator()( A0 const& , A1 const& , A2 const& , A3 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& ) const { m_fn(); }
+
+
+        template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12 , class A13 , class A14> void operator()( A0 const& , A1 const& , A2 const& , A3 const& , A4 const& , A5 const& , A6 const& , A7 const& , A8 const& , A9 const& , A10 const& , A11 const& , A12 const& , A13 const& , A14 const& ) const { m_fn(); }
+# 39 "/usr/include/boost-1_42/boost/python/detail/nullary_function_adaptor.hpp" 2
+
+ private:
+    NullaryFunction m_fn;
+};
+
+}}}
+# 14 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+
+
+
+
+
+
+  void pure_virtual_called();
+
+
+  template <class S, class T1, class T2>
+  struct replace_front2
+  {
+
+      typedef typename mpl::push_front<
+          typename mpl::push_front<
+              typename mpl::pop_front<
+                  typename mpl::pop_front<
+                      S
+                  >::type
+              >::type
+            , T2
+          >::type
+        , T1
+      >::type type;
+  };
+
+
+
+
+  template <class C, class S>
+  typename replace_front2<S,void,C&>::type
+  error_signature(S )
+  {
+      typedef typename replace_front2<S,void,C&>::type r;
+      return r();
+  }
+# 65 "/usr/include/boost-1_42/boost/python/pure_virtual.hpp"
+  template <class PointerToMemberFunction>
+  struct pure_virtual_visitor
+    : def_visitor<pure_virtual_visitor<PointerToMemberFunction> >
+  {
+      pure_virtual_visitor(PointerToMemberFunction pmf)
+        : m_pmf(pmf)
+      {}
+
+   private:
+      friend class python::def_visitor_access;
+
+      template <class C_, class Options>
+      void visit(C_& c, char const* name, Options& options) const
+      {
+
+          typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((!Options::has_default_implementation) == 0 ? false : true) >)> boost_static_assert_typedef_80;
+
+
+          c.def(
+              name
+            , m_pmf
+            , options.doc()
+            , options.keywords()
+            , options.policies()
+          );
+
+          typedef typename C_::metadata::held_type held_type;
+
+
+          c.def(
+              name
+            , make_function(
+                  detail::nullary_function_adaptor<void(*)()>(pure_virtual_called)
+                , default_call_policies()
+                , detail::error_signature<held_type>(detail::get_signature(m_pmf))
+              )
+          );
+      }
+
+   private:
+      PointerToMemberFunction m_pmf;
+  };
+}
+
+
+
+
+
+
+
+template <class PointerToMemberFunction>
+detail::pure_virtual_visitor<PointerToMemberFunction>
+pure_virtual(PointerToMemberFunction pmf)
+{
+    return detail::pure_virtual_visitor<PointerToMemberFunction>(pmf);
+}
+
+}}
+# 55 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/python/register_ptr_to_python.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/register_ptr_to_python.hpp"
+namespace boost { namespace python {
+
+template <class P>
+void register_ptr_to_python()
+{
+    typedef typename boost::python::pointee<P>::type X;
+    objects::class_value_wrapper<
+        P
+      , objects::make_ptr_instance<
+            X
+          , objects::pointer_holder<P,X>
+        >
+    >();
+}
+
+}}
+# 58 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/return_arg.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/python/return_arg.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 25 "/usr/include/boost-1_42/boost/python/return_arg.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <std::size_t>
+  struct return_arg_pos_argument_must_be_positive
+
+  {}
+
+  ;
+
+  struct return_none
+  {
+      template <class T> struct apply
+      {
+          struct type
+          {
+              static bool convertible()
+              {
+                  return true;
+              }
+
+              PyObject *operator()( typename value_arg<T>::type ) const
+              {
+                  return none();
+              }
+
+              PyTypeObject const *get_pytype() const { return converter::expected_pytype_for_arg<T>::get_pytype() ; }
+
+          };
+      };
+  };
+}
+
+template <
+    std::size_t arg_pos=1
+  , class Base = default_call_policies
+>
+struct return_arg : Base
+{
+ private:
+    static const bool legal = arg_pos > 0;
+
+ public:
+    typedef typename mpl::if_c<
+        legal
+        , detail::return_none
+        , detail::return_arg_pos_argument_must_be_positive<arg_pos>
+
+
+
+
+    >::type result_converter;
+
+    template <class ArgumentPackage>
+    static PyObject* postcall(ArgumentPackage const& args, PyObject* result)
+    {
+
+
+        typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((arg_pos > 0) == 0 ? false : true) >)> boost_static_assert_typedef_85;
+
+        result = Base::postcall(args,result);
+        if (!result)
+            return 0;
+        if ( --((PyObject*)(result))->ob_refcnt != 0) ; else ( (*(((PyObject*)((PyObject *)(result)))->ob_type)->tp_dealloc)((PyObject *)((PyObject *)(result))));
+        return incref( detail::get(mpl::int_<arg_pos-1>(),args) );
+    }
+
+    template <class Sig>
+    struct extract_return_type : mpl::at_c<Sig, arg_pos>
+    {
+    };
+
+};
+
+template <
+    class Base = default_call_policies
+    >
+struct return_self
+  : return_arg<1,Base>
+{};
+
+}}
+# 59 "/usr/include/boost-1_42/boost/python.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/return_opaque_pointer.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/python/return_opaque_pointer.hpp"
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class Pointee>
+  static void opaque_pointee(Pointee const volatile*)
+  {
+      force_instantiate(opaque<Pointee>::instance);
+  }
+}
+
+struct return_opaque_pointer
+{
+    template <class R>
+    struct apply
+    {
+        struct RETURN_OPAQUE_POINTER_EXPECTS_A_POINTER_TYPE; typedef struct RETURN_OPAQUE_POINTER_EXPECTS_A_POINTER_TYPE34 : boost::mpl::assert_ { static boost::mpl::failed ************ (RETURN_OPAQUE_POINTER_EXPECTS_A_POINTER_TYPE::************ assert_arg()) (R) { return 0; } } mpl_assert_arg34; enum { mpl_assertion_in_line_34 = sizeof( boost::mpl::assertion_failed<(is_pointer<R>::value)>( mpl_assert_arg34::assert_arg() ) ) };
+
+        struct type :
+          boost::python::to_python_value<
+              typename detail::value_arg<R>::type
+          >
+        {
+            type() { detail::opaque_pointee(R()); }
+        };
+    };
+};
+
+}}
+# 61 "/usr/include/boost-1_42/boost/python.hpp" 2
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/raw_function.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/python/raw_function.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 17 "/usr/include/boost-1_42/boost/python/raw_function.hpp" 2
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  template <class F>
+  struct raw_dispatcher
+  {
+      raw_dispatcher(F f) : f(f) {}
+
+      PyObject* operator()(PyObject* args, PyObject* keywords)
+      {
+          return incref(
+              object(
+                  f(
+                      tuple(borrowed_reference(args))
+                    , keywords ? dict(borrowed_reference(keywords)) : dict()
+                  )
+              ).ptr()
+          );
+      }
+
+   private:
+      F f;
+  };
+
+  object make_raw_function(objects::py_function);
+}
+
+template <class F>
+object raw_function(F f, std::size_t min_args = 0)
+{
+    return detail::make_raw_function(
+        objects::py_function(
+            detail::raw_dispatcher<F>(f)
+          , mpl::vector1<PyObject*>()
+          , min_args
+          , (std::numeric_limits<unsigned>::max)()
+        )
+    );
+}
+
+}}
+# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/slice.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/python/slice.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp"
+namespace boost {
+# 27 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp"
+template <class Iterator>
+struct iterator_value
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::value_type type;
+};
+
+template <class Iterator>
+struct iterator_reference
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+};
+
+
+template <class Iterator>
+struct iterator_pointer
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::pointer type;
+};
+
+template <class Iterator>
+struct iterator_difference
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::difference_type type;
+};
+
+template <class Iterator>
+struct iterator_category
+{
+    typedef typename boost::detail::iterator_traits<Iterator>::iterator_category type;
+};
+# 90 "/usr/include/boost-1_42/boost/iterator/iterator_traits.hpp"
+}
+# 16 "/usr/include/boost-1_42/boost/python/slice.hpp" 2
+
+
+
+
+namespace boost { namespace python {
+
+namespace detail
+{
+  class slice_base : public object
+  {
+   public:
+
+
+
+
+
+
+
+      object start() const;
+      object stop() const;
+      object step() const;
+
+   protected:
+      explicit slice_base(PyObject*, PyObject*, PyObject*);
+
+      inline explicit slice_base(python::detail::borrowed_reference p) : object(p) {} inline explicit slice_base(python::detail::new_reference p) : object(p) {} inline explicit slice_base(python::detail::new_non_null_reference p) : object(p) {}
+  };
+}
+
+class slice : public detail::slice_base
+{
+    typedef detail::slice_base base;
+ public:
+
+    slice() : base(0,0,0) {}
+
+
+
+    template<typename Integer1, typename Integer2>
+    slice( Integer1 start, Integer2 stop)
+        : base( object(start).ptr(), object(stop).ptr(), 0 )
+    {}
+
+    template<typename Integer1, typename Integer2, typename Integer3>
+    slice( Integer1 start, Integer2 stop, Integer3 stride)
+        : base( object(start).ptr(), object(stop).ptr(), object(stride).ptr() )
+    {}
+# 103 "/usr/include/boost-1_42/boost/python/slice.hpp"
+    template<typename RandomAccessIterator>
+    struct range
+    {
+        RandomAccessIterator start;
+        RandomAccessIterator stop;
+        typename iterator_difference<RandomAccessIterator>::type step;
+    };
+
+    template<typename RandomAccessIterator>
+    slice::range<RandomAccessIterator>
+    get_indicies( const RandomAccessIterator& begin,
+        const RandomAccessIterator& end) const
+    {
+
+
+
+        slice::range<RandomAccessIterator> ret;
+
+        typedef typename iterator_difference<RandomAccessIterator>::type difference_type;
+        difference_type max_dist = boost::detail::distance(begin, end);
+
+        object slice_start = this->start();
+        object slice_stop = this->stop();
+        object slice_step = this->step();
+
+
+        if (slice_step == object()) {
+            ret.step = 1;
+        }
+        else {
+            ret.step = extract<long>( slice_step);
+            if (ret.step == 0) {
+                PyErr_SetString( PyExc_IndexError, "step size cannot be zero.");
+                throw_error_already_set();
+            }
+        }
+
+
+        if (slice_start == object()) {
+            if (ret.step < 0) {
+                ret.start = end;
+                --ret.start;
+            }
+            else
+                ret.start = begin;
+        }
+        else {
+            difference_type i = extract<long>( slice_start);
+            if (i >= max_dist && ret.step > 0)
+                    throw std::invalid_argument( "Zero-length slice");
+            if (i >= 0) {
+                ret.start = begin;
+                using std::min;
+                std::advance( ret.start, min (i, max_dist-1));
+            }
+            else {
+                if (i < -max_dist && ret.step < 0)
+                    throw std::invalid_argument( "Zero-length slice");
+                ret.start = end;
+
+                std::advance( ret.start, (-i < max_dist) ? i : -max_dist );
+            }
+        }
+
+
+
+        if (slice_stop == object()) {
+            if (ret.step < 0) {
+                ret.stop = begin;
+            }
+            else {
+                ret.stop = end;
+                std::advance( ret.stop, -1);
+            }
+        }
+        else {
+            difference_type i = extract<long>(slice_stop);
+
+            if (ret.step < 0) {
+                if (i+1 >= max_dist || i == -1)
+                    throw std::invalid_argument( "Zero-length slice");
+
+                if (i >= 0) {
+                    ret.stop = begin;
+                    std::advance( ret.stop, i+1);
+                }
+                else {
+                    ret.stop = end;
+                    std::advance( ret.stop, (-i < max_dist) ? i : -max_dist);
+                }
+            }
+            else {
+                if (i == 0 || -i >= max_dist)
+                    throw std::invalid_argument( "Zero-length slice");
+
+                if (i > 0) {
+                    ret.stop = begin;
+                    std::advance( ret.stop, (std::min)( i-1, max_dist-1));
+                }
+                else {
+                    ret.stop = end;
+                    std::advance( ret.stop, i-1);
+                }
+            }
+        }
+
+
+
+
+
+
+        typename iterator_difference<RandomAccessIterator>::type final_dist =
+            boost::detail::distance( ret.start, ret.stop);
+
+
+
+        if (final_dist == 0)
+            return ret;
+
+
+
+
+        if ((final_dist > 0) != (ret.step > 0))
+            throw std::invalid_argument( "Zero-length slice.");
+
+
+
+
+
+        if (final_dist < 0) {
+            difference_type remainder = -final_dist % -ret.step;
+            std::advance( ret.stop, remainder);
+        }
+        else {
+            difference_type remainder = final_dist % ret.step;
+            std::advance( ret.stop, -remainder);
+        }
+
+        return ret;
+    }
+
+ public:
+
+
+
+
+    inline explicit slice(python::detail::borrowed_reference p) : detail::slice_base(p) {} inline explicit slice(python::detail::new_reference p) : detail::slice_base(p) {} inline explicit slice(python::detail::new_non_null_reference p) : detail::slice_base(p) {}
+};
+
+
+namespace converter {
+
+template<>
+struct object_manager_traits<slice>
+    : pytype_object_manager_traits<&PySlice_Type, slice>
+{
+};
+
+}
+
+} }
+# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
+# 1 "/usr/include/boost-1_42/boost/scoped_ptr.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/scoped_ptr.hpp"
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp"
+# 1 "/usr/include/boost-1_42/boost/assert.hpp" 1
+# 36 "/usr/include/boost-1_42/boost/assert.hpp"
+# 1 "/usr/include/assert.h" 1 3 4
+# 37 "/usr/include/boost-1_42/boost/assert.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp" 2
+
+
+
+
+
+
+
+namespace boost
+{
+# 39 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp"
+template<class T> class scoped_ptr
+{
+private:
+
+    T * px;
+
+    scoped_ptr(scoped_ptr const &);
+    scoped_ptr & operator=(scoped_ptr const &);
+
+    typedef scoped_ptr<T> this_type;
+
+    void operator==( scoped_ptr const& ) const;
+    void operator!=( scoped_ptr const& ) const;
+
+public:
+
+    typedef T element_type;
+
+    explicit scoped_ptr( T * p = 0 ): px( p )
+    {
+
+
+
+    }
+
+
+
+    explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() )
+    {
+
+
+
+    }
+
+
+
+    ~scoped_ptr()
+    {
+
+
+
+        boost::checked_delete( px );
+    }
+
+    void reset(T * p = 0)
+    {
+        (static_cast<void> (0));
+        this_type(p).swap(*this);
+    }
+
+    T & operator*() const
+    {
+        (static_cast<void> (0));
+        return *px;
+    }
+
+    T * operator->() const
+    {
+        (static_cast<void> (0));
+        return px;
+    }
+
+    T * get() const
+    {
+        return px;
+    }
+
+
+# 1 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp" 1
+# 43 "/usr/include/boost-1_42/boost/smart_ptr/detail/operator_bool.hpp"
+    typedef T * this_type::*unspecified_bool_type;
+
+    operator unspecified_bool_type() const
+    {
+        return px == 0? 0: &this_type::px;
+    }
+
+
+
+
+    bool operator! () const
+    {
+        return px == 0;
+    }
+# 108 "/usr/include/boost-1_42/boost/smart_ptr/scoped_ptr.hpp" 2
+
+    void swap(scoped_ptr & b)
+    {
+        T * tmp = b.px;
+        b.px = px;
+        px = tmp;
+    }
+};
+
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
+{
+    a.swap(b);
+}
+
+
+
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p)
+{
+    return p.get();
+}
+
+}
+# 15 "/usr/include/boost-1_42/boost/scoped_ptr.hpp" 2
+# 11 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/detail/binary_search.hpp" 1
+# 34 "/usr/include/boost-1_42/boost/detail/binary_search.hpp"
+namespace boost { namespace detail {
+
+template <class ForwardIter, class Tp>
+ForwardIter lower_bound(ForwardIter first, ForwardIter last,
+                             const Tp& val)
+{
+    typedef detail::iterator_traits<ForwardIter> traits;
+
+    typename traits::difference_type len = boost::detail::distance(first, last);
+    typename traits::difference_type half;
+    ForwardIter middle;
+
+    while (len > 0) {
+      half = len >> 1;
+      middle = first;
+      std::advance(middle, half);
+      if (*middle < val) {
+        first = middle;
+        ++first;
+        len = len - half - 1;
+      }
+      else
+        len = half;
+    }
+    return first;
+}
+
+template <class ForwardIter, class Tp, class Compare>
+ForwardIter lower_bound(ForwardIter first, ForwardIter last,
+                              const Tp& val, Compare comp)
+{
+  typedef detail::iterator_traits<ForwardIter> traits;
+
+  typename traits::difference_type len = boost::detail::distance(first, last);
+  typename traits::difference_type half;
+  ForwardIter middle;
+
+  while (len > 0) {
+    half = len >> 1;
+    middle = first;
+    std::advance(middle, half);
+    if (comp(*middle, val)) {
+      first = middle;
+      ++first;
+      len = len - half - 1;
+    }
+    else
+      len = half;
+  }
+  return first;
+}
+
+template <class ForwardIter, class Tp>
+ForwardIter upper_bound(ForwardIter first, ForwardIter last,
+                           const Tp& val)
+{
+  typedef detail::iterator_traits<ForwardIter> traits;
+
+  typename traits::difference_type len = boost::detail::distance(first, last);
+  typename traits::difference_type half;
+  ForwardIter middle;
+
+  while (len > 0) {
+    half = len >> 1;
+    middle = first;
+    std::advance(middle, half);
+    if (val < *middle)
+      len = half;
+    else {
+      first = middle;
+      ++first;
+      len = len - half - 1;
+    }
+  }
+  return first;
+}
+
+template <class ForwardIter, class Tp, class Compare>
+ForwardIter upper_bound(ForwardIter first, ForwardIter last,
+                           const Tp& val, Compare comp)
+{
+  typedef detail::iterator_traits<ForwardIter> traits;
+
+  typename traits::difference_type len = boost::detail::distance(first, last);
+  typename traits::difference_type half;
+  ForwardIter middle;
+
+  while (len > 0) {
+    half = len >> 1;
+    middle = first;
+    std::advance(middle, half);
+    if (comp(val, *middle))
+      len = half;
+    else {
+      first = middle;
+      ++first;
+      len = len - half - 1;
+    }
+  }
+  return first;
+}
+
+template <class ForwardIter, class Tp>
+std::pair<ForwardIter, ForwardIter>
+equal_range(ForwardIter first, ForwardIter last, const Tp& val)
+{
+  typedef detail::iterator_traits<ForwardIter> traits;
+
+  typename traits::difference_type len = boost::detail::distance(first, last);
+  typename traits::difference_type half;
+  ForwardIter middle, left, right;
+
+  while (len > 0) {
+    half = len >> 1;
+    middle = first;
+    std::advance(middle, half);
+    if (*middle < val) {
+      first = middle;
+      ++first;
+      len = len - half - 1;
+    }
+    else if (val < *middle)
+      len = half;
+    else {
+      left = boost::detail::lower_bound(first, middle, val);
+      std::advance(first, len);
+      right = boost::detail::upper_bound(++middle, first, val);
+      return std::pair<ForwardIter, ForwardIter>(left, right);
+    }
+  }
+  return std::pair<ForwardIter, ForwardIter>(first, first);
+}
+
+template <class ForwardIter, class Tp, class Compare>
+std::pair<ForwardIter, ForwardIter>
+equal_range(ForwardIter first, ForwardIter last, const Tp& val,
+              Compare comp)
+{
+  typedef detail::iterator_traits<ForwardIter> traits;
+
+  typename traits::difference_type len = boost::detail::distance(first, last);
+  typename traits::difference_type half;
+  ForwardIter middle, left, right;
+
+  while (len > 0) {
+    half = len >> 1;
+    middle = first;
+    std::advance(middle, half);
+    if (comp(*middle, val)) {
+      first = middle;
+      ++first;
+      len = len - half - 1;
+    }
+    else if (comp(val, *middle))
+      len = half;
+    else {
+      left = boost::detail::lower_bound(first, middle, val, comp);
+      std::advance(first, len);
+      right = boost::detail::upper_bound(++middle, first, val, comp);
+      return std::pair<ForwardIter, ForwardIter>(left, right);
+    }
+  }
+  return std::pair<ForwardIter, ForwardIter>(first, first);
+}
+
+template <class ForwardIter, class Tp>
+bool binary_search(ForwardIter first, ForwardIter last,
+                   const Tp& val) {
+  ForwardIter i = boost::detail::lower_bound(first, last, val);
+  return i != last && !(val < *i);
+}
+
+template <class ForwardIter, class Tp, class Compare>
+bool binary_search(ForwardIter first, ForwardIter last,
+                   const Tp& val,
+                   Compare comp) {
+  ForwardIter i = boost::detail::lower_bound(first, last, val, comp);
+  return i != last && !comp(val, *i);
+}
+
+}}
+# 13 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/cast.hpp" 1
+# 32 "/usr/include/boost-1_42/boost/numeric/conversion/cast.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/conversion_traits.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/numeric/conversion/conversion_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/equal_to.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/equal_to.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 1
+# 27 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct equal_to_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct equal_to_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct equal_to_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct equal_to_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct equal_to_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    >
+struct equal_to
+
+    : equal_to_impl<
+          typename equal_to_tag<N1>::type
+        , typename equal_to_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+};
+
+template<> struct equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal_to< na , na > result_; typedef equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal_to< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+
+template<>
+struct equal_to_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : bool_< ( N1::value == N2::value ) >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/mpl/aux_/comparison_op.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/equal_to.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp" 2
+
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+   template< class T1, class T2>
+   struct equal_to
+   {
+
+
+       enum { x = ( T1::value == T2::value ) };
+
+       static const bool value = x;
+
+       typedef mpl::bool_<value> type;
+# 48 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
+   };
+# 59 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
+  template<class Value,
+           class Case0Val,
+           class Case1Val,
+           class Case2Val,
+           class Case0Type,
+           class Case1Type,
+           class Case2Type,
+           class DefaultType
+          >
+  struct ct_switch4
+  {
+    typedef mpl::identity<Case0Type> Case0TypeQ ;
+    typedef mpl::identity<Case1Type> Case1TypeQ ;
+
+    typedef equal_to<Value,Case0Val> is_case0 ;
+    typedef equal_to<Value,Case1Val> is_case1 ;
+    typedef equal_to<Value,Case2Val> is_case2 ;
+
+    typedef mpl::if_<is_case2,Case2Type,DefaultType> choose_2_3Q ;
+    typedef mpl::eval_if<is_case1,Case1TypeQ,choose_2_3Q> choose_1_2_3Q ;
+
+    typedef typename
+      mpl::eval_if<is_case0,Case0TypeQ,choose_1_2_3Q>::type
+        type ;
+  } ;
+# 97 "/usr/include/boost-1_42/boost/numeric/conversion/detail/meta.hpp"
+  template<class expr0, class expr1, class TT, class TF, class FT, class FF>
+  struct for_both
+  {
+    typedef mpl::identity<TF> TF_Q ;
+    typedef mpl::identity<TT> TT_Q ;
+
+    typedef typename mpl::not_<expr0>::type not_expr0 ;
+    typedef typename mpl::not_<expr1>::type not_expr1 ;
+
+    typedef typename mpl::and_<expr0,expr1>::type caseTT ;
+    typedef typename mpl::and_<expr0,not_expr1>::type caseTF ;
+    typedef typename mpl::and_<not_expr0,expr1>::type caseFT ;
+
+    typedef mpl::if_<caseFT,FT,FF> choose_FT_FF_Q ;
+    typedef mpl::eval_if<caseTF,TF_Q,choose_FT_FF_Q> choose_TF_FT_FF_Q ;
+
+    typedef typename mpl::eval_if<caseTT,TT_Q,choose_TF_FT_FF_Q>::type type ;
+  } ;
+
+} } }
+# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/int_float_mixture_enum.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/numeric/conversion/int_float_mixture_enum.hpp"
+namespace boost { namespace numeric
+{
+  enum int_float_mixture_enum
+  {
+     integral_to_integral
+    ,integral_to_float
+    ,float_to_integral
+    ,float_to_float
+  } ;
+
+} }
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp" 2
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+  typedef mpl::integral_c<int_float_mixture_enum, integral_to_integral> int2int_c ;
+  typedef mpl::integral_c<int_float_mixture_enum, integral_to_float> int2float_c ;
+  typedef mpl::integral_c<int_float_mixture_enum, float_to_integral> float2int_c ;
+  typedef mpl::integral_c<int_float_mixture_enum, float_to_float> float2float_c ;
+
+
+
+
+
+
+
+  template<class T,class S>
+  struct get_int_float_mixture
+  {
+    typedef mpl::bool_< ::std::numeric_limits<S>::is_integer > S_int ;
+    typedef mpl::bool_< ::std::numeric_limits<T>::is_integer > T_int ;
+
+    typedef typename
+      for_both<S_int, T_int, int2int_c, int2float_c, float2int_c, float2float_c>::type
+        type ;
+  } ;
+# 55 "/usr/include/boost-1_42/boost/numeric/conversion/detail/int_float_mixture.hpp"
+  template<class IntFloatMixture, class Int2Int, class Int2Float, class Float2Int, class Float2Float>
+  struct for_int_float_mixture
+  {
+    typedef typename
+      ct_switch4<IntFloatMixture
+                 ,int2int_c, int2float_c, float2int_c
+                 ,Int2Int , Int2Float , Float2Int , Float2Float
+                >::type
+        type ;
+  } ;
+
+} } }
+# 19 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/sign_mixture_enum.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/numeric/conversion/sign_mixture_enum.hpp"
+namespace boost { namespace numeric
+{
+  enum sign_mixture_enum
+  {
+     unsigned_to_unsigned
+    ,signed_to_signed
+    ,signed_to_unsigned
+    ,unsigned_to_signed
+  } ;
+
+} }
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp" 2
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
+  typedef mpl::integral_c<sign_mixture_enum, signed_to_signed> sig2sig_c ;
+  typedef mpl::integral_c<sign_mixture_enum, signed_to_unsigned> sig2unsig_c ;
+  typedef mpl::integral_c<sign_mixture_enum, unsigned_to_signed> unsig2sig_c ;
+
+
+
+
+
+
+
+  template<class T,class S>
+  struct get_sign_mixture
+  {
+    typedef mpl::bool_< ::std::numeric_limits<S>::is_signed > S_signed ;
+    typedef mpl::bool_< ::std::numeric_limits<T>::is_signed > T_signed ;
+
+    typedef typename
+      for_both<S_signed, T_signed, sig2sig_c, sig2unsig_c, unsig2sig_c, unsig2unsig_c>::type
+        type ;
+  } ;
+# 55 "/usr/include/boost-1_42/boost/numeric/conversion/detail/sign_mixture.hpp"
+  template<class SignMixture, class Sig2Sig, class Sig2Unsig, class Unsig2Sig, class Unsig2Unsig>
+  struct for_sign_mixture
+  {
+    typedef typename
+      ct_switch4<SignMixture
+                 , sig2sig_c, sig2unsig_c, unsig2sig_c
+                 , Sig2Sig , Sig2Unsig , Unsig2Sig , Unsig2Unsig
+                >::type
+        type ;
+  } ;
+
+} } }
+# 20 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/numeric/conversion/udt_builtin_mixture_enum.hpp"
+namespace boost { namespace numeric
+{
+  enum udt_builtin_mixture_enum
+  {
+     builtin_to_builtin
+    ,builtin_to_udt
+    ,udt_to_builtin
+    ,udt_to_udt
+  } ;
+
+} }
+# 16 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 2
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
+  typedef mpl::integral_c<udt_builtin_mixture_enum, builtin_to_udt> builtin2udt_c ;
+  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_builtin> udt2builtin_c ;
+  typedef mpl::integral_c<udt_builtin_mixture_enum, udt_to_udt> udt2udt_c ;
+# 37 "/usr/include/boost-1_42/boost/numeric/conversion/detail/udt_builtin_mixture.hpp"
+  template<class UdtMixture, class BuiltIn2BuiltIn, class BuiltIn2Udt, class Udt2BuiltIn, class Udt2Udt>
+  struct for_udt_builtin_mixture
+  {
+    typedef typename
+      ct_switch4<UdtMixture
+                 , builtin2builtin_c, builtin2udt_c, udt2builtin_c
+                 , BuiltIn2BuiltIn , BuiltIn2Udt , Udt2BuiltIn , Udt2Udt
+                >::type
+        type ;
+  } ;
+
+
+
+
+
+
+
+  template<class T,class S>
+  struct get_udt_builtin_mixture
+  {
+    typedef is_arithmetic<S> S_builtin ;
+    typedef is_arithmetic<T> T_builtin ;
+
+    typedef typename
+      for_both<S_builtin, T_builtin, builtin2builtin_c, builtin2udt_c, udt2builtin_c, udt2udt_c>::type
+        type ;
+  } ;
+
+} } }
+# 21 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/times.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/mpl/times.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 1
+# 22 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/apply_wrap.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/mpl/aux_/numeric_op.hpp" 2
+# 27 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
+
+
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/times.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessed/gcc/times.hpp"
+namespace boost { namespace mpl {
+
+template<
+      typename Tag1
+    , typename Tag2
+    >
+struct times_impl
+    : if_c<
+          ( Tag1::value
+              > Tag2::value
+            )
+
+        , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 >
+        , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 >
+        >::type
+{
+};
+
+
+template<> struct times_impl< na,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct times_impl< na,Tag >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename Tag > struct times_impl< Tag,na >
+{
+    template< typename U1, typename U2 > struct apply
+    {
+        typedef apply type;
+        static const int value = 0;
+    };
+};
+
+template< typename T > struct times_tag
+{
+    typedef typename T::tag type;
+};
+
+template<
+      typename N1 = na
+    , typename N2 = na
+    , typename N3 = na, typename N4 = na, typename N5 = na
+    >
+struct times
+    : times< times< times< times< N1,N2 >, N3>, N4>, N5>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3, typename N4
+    >
+struct times< N1,N2,N3,N4,na >
+
+    : times< times< times< N1,N2 >, N3>, N4>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2, typename N3
+    >
+struct times< N1,N2,N3,na,na >
+
+    : times< times< N1,N2 >, N3>
+{
+   
+
+
+
+
+};
+
+template<
+      typename N1, typename N2
+    >
+struct times< N1,N2,na,na,na >
+    : times_impl<
+          typename times_tag<N1>::type
+        , typename times_tag<N2>::type
+        >::template apply< N1,N2 >::type
+{
+   
+
+
+
+
+
+};
+
+template<> struct times< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : times< T1 , T2 > { }; }; template< typename Tag > struct lambda< times< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef times< na , na > result_; typedef times< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< times< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< times< na , na > > : int_<-1> { }; }
+
+}}
+
+namespace boost { namespace mpl {
+template<>
+struct times_impl< integral_c_tag,integral_c_tag >
+{
+    template< typename N1, typename N2 > struct apply
+
+        : integral_c<
+              typename aux::largest_int<
+                  typename N1::value_type
+                , typename N2::value_type
+                >::type
+            , ( N1::value
+                  * N2::value
+                )
+            >
+    {
+    };
+};
+
+}}
+# 38 "/usr/include/boost-1_42/boost/mpl/aux_/include_preprocessed.hpp" 2
+# 35 "/usr/include/boost-1_42/boost/mpl/aux_/arithmetic_op.hpp" 2
+# 20 "/usr/include/boost-1_42/boost/mpl/times.hpp" 2
+# 18 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/aux_/preprocessor/default_params.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/multiplies.hpp" 2
+
+
+
+
+
+namespace boost { namespace mpl {
+
+
+
+
+
+
+
+template<
+      typename N1 = na , typename N2 = na , typename N3 = na , typename N4 = na , typename N5 = na
+    >
+struct multiplies
+    : times< N1 , N2 , N3 , N4 , N5 >
+{
+   
+
+
+
+
+};
+
+template<> struct multiplies< na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct apply : multiplies< T1 , T2 , T3 , T4 , T5 > { }; }; template< typename Tag > struct lambda< multiplies< na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef multiplies< na , na , na , na , na > result_; typedef multiplies< na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< multiplies< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< multiplies< na , na , na , na , na > > : int_<-1> { }; }
+
+
+
+}}
+# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp" 2
+# 28 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp"
+namespace boost { namespace numeric { namespace convdetail
+{
+
+
+
+
+
+    template<class T,class S>
+    struct subranged_Sig2Unsig
+    {
+
+
+      typedef mpl::true_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Unsig2Sig
+    {
+# 62 "/usr/include/boost-1_42/boost/numeric/conversion/detail/is_subranged.hpp"
+       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
+       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;
+
+
+       typedef typename T_digits::next u_T_digits ;
+
+       typedef mpl::int_<2> Two ;
+
+       typedef typename mpl::multiplies<S_digits,Two>::type S_digits_times_2 ;
+
+       typedef typename mpl::less<u_T_digits,S_digits_times_2>::type type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_SameSign
+    {
+
+
+       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
+       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;
+
+       typedef typename mpl::less<T_digits,S_digits>::type type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Int2Float
+    {
+      typedef mpl::false_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Float2Int
+    {
+      typedef mpl::true_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Float2Float
+    {
+
+
+
+      typedef mpl::int_< ::std::numeric_limits<S>::digits > S_mantisa ;
+      typedef mpl::int_< ::std::numeric_limits<T>::digits > T_mantisa ;
+
+      typedef mpl::int_< ::std::numeric_limits<S>::max_exponent > S_exponent ;
+      typedef mpl::int_< ::std::numeric_limits<T>::max_exponent > T_exponent ;
+
+      typedef typename mpl::less<T_exponent,S_exponent>::type T_smaller_exponent ;
+
+      typedef typename mpl::equal_to<T_exponent,S_exponent>::type equal_exponents ;
+
+      typedef mpl::less<T_mantisa,S_mantisa> T_smaller_mantisa ;
+
+      typedef mpl::eval_if<equal_exponents,T_smaller_mantisa,mpl::false_> not_bigger_exponent_case ;
+
+      typedef typename
+        mpl::eval_if<T_smaller_exponent,mpl::true_,not_bigger_exponent_case>::type
+          type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Udt2BuiltIn
+    {
+      typedef mpl::true_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_BuiltIn2Udt
+    {
+      typedef mpl::false_ type ;
+    } ;
+
+
+    template<class T,class S>
+    struct subranged_Udt2Udt
+    {
+      typedef mpl::false_ type ;
+    } ;
+
+
+
+
+
+    template<class T,class S>
+    struct get_subranged_Int2Int
+    {
+      typedef subranged_SameSign<T,S> Sig2Sig ;
+      typedef subranged_Sig2Unsig<T,S> Sig2Unsig ;
+      typedef subranged_Unsig2Sig<T,S> Unsig2Sig ;
+      typedef Sig2Sig Unsig2Unsig ;
+
+      typedef typename get_sign_mixture<T,S>::type sign_mixture ;
+
+      typedef typename
+        for_sign_mixture<sign_mixture, Sig2Sig, Sig2Unsig, Unsig2Sig, Unsig2Unsig>::type
+           type ;
+    } ;
+
+    template<class T,class S>
+    struct get_subranged_BuiltIn2BuiltIn
+    {
+      typedef get_subranged_Int2Int<T,S> Int2IntQ ;
+
+      typedef subranged_Int2Float <T,S> Int2Float ;
+      typedef subranged_Float2Int <T,S> Float2Int ;
+      typedef subranged_Float2Float<T,S> Float2Float ;
+
+      typedef mpl::identity<Int2Float > Int2FloatQ ;
+      typedef mpl::identity<Float2Int > Float2IntQ ;
+      typedef mpl::identity<Float2Float> Float2FloatQ ;
+
+      typedef typename get_int_float_mixture<T,S>::type int_float_mixture ;
+
+      typedef for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ> for_ ;
+
+      typedef typename for_::type selected ;
+
+      typedef typename selected::type type ;
+    } ;
+
+    template<class T,class S>
+    struct get_subranged
+    {
+      typedef get_subranged_BuiltIn2BuiltIn<T,S> BuiltIn2BuiltInQ ;
+
+      typedef subranged_BuiltIn2Udt<T,S> BuiltIn2Udt ;
+      typedef subranged_Udt2BuiltIn<T,S> Udt2BuiltIn ;
+      typedef subranged_Udt2Udt<T,S> Udt2Udt ;
+
+      typedef mpl::identity<BuiltIn2Udt> BuiltIn2UdtQ ;
+      typedef mpl::identity<Udt2BuiltIn> Udt2BuiltInQ ;
+      typedef mpl::identity<Udt2Udt > Udt2UdtQ ;
+
+      typedef typename get_udt_builtin_mixture<T,S>::type udt_builtin_mixture ;
+
+      typedef typename
+        for_udt_builtin_mixture<udt_builtin_mixture, BuiltIn2BuiltInQ, BuiltIn2UdtQ, Udt2BuiltInQ, Udt2UdtQ>::type
+          selected ;
+
+      typedef typename selected::type selected2 ;
+
+      typedef typename selected2::type type ;
+    } ;
+
+
+
+
+
+  template<class T, class S>
+  struct get_is_subranged
+  {
+    typedef get_subranged<T,S> non_trivial_case ;
+    typedef mpl::identity<mpl::false_> trivial_case ;
+
+    typedef is_same<T,S> is_trivial ;
+
+    typedef typename mpl::if_<is_trivial,trivial_case,non_trivial_case>::type selected ;
+
+    typedef typename selected::type type ;
+  } ;
+
+} } }
+# 22 "/usr/include/boost-1_42/boost/numeric/conversion/detail/conversion_traits.hpp" 2
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+
+
+
+
+  template<class T,class S>
+  struct non_trivial_traits_impl
+  {
+    typedef typename get_int_float_mixture <T,S>::type int_float_mixture ;
+    typedef typename get_sign_mixture <T,S>::type sign_mixture ;
+    typedef typename get_udt_builtin_mixture <T,S>::type udt_builtin_mixture ;
+
+    typedef typename get_is_subranged<T,S>::type subranged ;
+
+    typedef mpl::false_ trivial ;
+
+    typedef T target_type ;
+    typedef S source_type ;
+    typedef T result_type ;
+
+    typedef typename mpl::if_< is_arithmetic<S>, S, S const&>::type argument_type ;
+
+    typedef typename mpl::if_<subranged,S,T>::type supertype ;
+    typedef typename mpl::if_<subranged,T,S>::type subtype ;
+  } ;
+
+
+
+
+
+
+  template<class N>
+  struct trivial_traits_impl
+  {
+    typedef typename get_int_float_mixture <N,N>::type int_float_mixture ;
+    typedef typename get_sign_mixture <N,N>::type sign_mixture ;
+    typedef typename get_udt_builtin_mixture<N,N>::type udt_builtin_mixture ;
+
+    typedef mpl::false_ subranged ;
+    typedef mpl::true_ trivial ;
+
+    typedef N target_type ;
+    typedef N source_type ;
+    typedef N const& result_type ;
+    typedef N const& argument_type ;
+
+    typedef N supertype ;
+    typedef N subtype ;
+
+  } ;
+
+
+
+
+  template<class T, class S>
+  struct get_conversion_traits
+  {
+    typedef typename remove_cv<T>::type target_type ;
+    typedef typename remove_cv<S>::type source_type ;
+
+    typedef typename is_same<target_type,source_type>::type is_trivial ;
+
+    typedef trivial_traits_impl <target_type> trivial_imp ;
+    typedef non_trivial_traits_impl<target_type,source_type> non_trivial_imp ;
+
+    typedef typename mpl::if_<is_trivial,trivial_imp,non_trivial_imp>::type type ;
+  } ;
+
+} } }
+# 14 "/usr/include/boost-1_42/boost/numeric/conversion/conversion_traits.hpp" 2
+
+
+
+namespace boost { namespace numeric
+{
+
+template<class T, class S>
+struct conversion_traits
+    : convdetail::get_conversion_traits<T,S>::type
+{
+
+
+
+
+
+
+
+} ;
+
+} }
+# 14 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp"
+# 1 "/usr/include/boost-1_42/boost/config/no_tr1/cmath.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/config/no_tr1/cmath.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cmath" 3
+# 22 "/usr/include/boost-1_42/boost/config/no_tr1/cmath.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp" 2
+# 24 "/usr/include/boost-1_42/boost/numeric/conversion/converter_policies.hpp"
+namespace boost { namespace numeric
+{
+
+template<class S>
+struct Trunc
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+
+    using std::floor ;
+    using std::ceil ;
+
+
+    return s < static_cast<S>(0) ? ceil(s) : floor(s) ;
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_toward_zero> round_style ;
+} ;
+
+
+
+template<class S>
+struct Floor
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+
+    using std::floor ;
+
+
+    return floor(s) ;
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_toward_neg_infinity> round_style ;
+} ;
+
+template<class S>
+struct Ceil
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+
+    using std::ceil ;
+
+
+    return ceil(s) ;
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_toward_infinity> round_style ;
+} ;
+
+template<class S>
+struct RoundEven
+{
+  typedef S source_type ;
+
+  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;
+
+  static source_type nearbyint ( argument_type s )
+  {
+
+
+
+    using std::floor ;
+    using std::ceil ;
+
+
+
+    S prev = floor(s);
+    S next = ceil(s);
+
+    S rt = (s - prev) - (next - s);
+
+    S const zero(0.0);
+    S const two(2.0);
+
+    if ( rt < zero )
+      return prev;
+    else if ( rt > zero )
+      return next;
+    else
+    {
+      bool is_prev_even = two * floor(prev / two) == prev ;
+      return ( is_prev_even ? prev : next ) ;
+    }
+  }
+
+  typedef mpl::integral_c< std::float_round_style, std::round_to_nearest> round_style ;
+} ;
+
+
+enum range_check_result
+{
+  cInRange = 0 ,
+  cNegOverflow = 1 ,
+  cPosOverflow = 2
+} ;
+
+class bad_numeric_cast : public std::bad_cast
+{
+  public:
+
+    virtual const char * what() const throw()
+      { return "bad numeric conversion: overflow"; }
+};
+
+class negative_overflow : public bad_numeric_cast
+{
+  public:
+
+    virtual const char * what() const throw()
+      { return "bad numeric conversion: negative overflow"; }
+};
+class positive_overflow : public bad_numeric_cast
+{
+  public:
+
+    virtual const char * what() const throw()
+      { return "bad numeric conversion: positive overflow"; }
+};
+
+struct def_overflow_handler
+{
+  void operator() ( range_check_result r )
+  {
+    if ( r == cNegOverflow )
+      throw negative_overflow() ;
+    else if ( r == cPosOverflow )
+           throw positive_overflow() ;
+  }
+} ;
+
+struct silent_overflow_handler
+{
+  void operator() ( range_check_result ) {}
+} ;
+
+template<class Traits>
+struct raw_converter
+{
+  typedef typename Traits::result_type result_type ;
+  typedef typename Traits::argument_type argument_type ;
+
+  static result_type low_level_convert ( argument_type s ) { return static_cast<result_type>(s) ; }
+} ;
+
+struct UseInternalRangeChecker {} ;
+
+} }
+# 15 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 2
+
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/bounds.hpp" 1
+# 13 "/usr/include/boost-1_42/boost/numeric/conversion/bounds.hpp"
+# 1 "/usr/include/boost-1_42/boost/numeric/conversion/detail/bounds.hpp" 1
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/detail/bounds.hpp"
+namespace boost { namespace numeric { namespace boundsdetail
+{
+  template<class N>
+  class Integral
+  {
+      typedef std::numeric_limits<N> limits ;
+
+    public :
+
+      static N lowest () { return limits::min (); }
+      static N highest () { return limits::max (); }
+      static N smallest() { return static_cast<N>(1); }
+  } ;
+
+  template<class N>
+  class Float
+  {
+      typedef std::numeric_limits<N> limits ;
+
+    public :
+
+      static N lowest () { return static_cast<N>(-limits::max ()) ; }
+      static N highest () { return limits::max (); }
+      static N smallest() { return limits::min (); }
+  } ;
+
+  template<class N>
+  struct get_impl
+  {
+    typedef mpl::bool_< ::std::numeric_limits<N>::is_integer > is_int ;
+
+    typedef Integral<N> impl_int ;
+    typedef Float <N> impl_float ;
+
+    typedef typename mpl::if_<is_int,impl_int,impl_float>::type type ;
+  } ;
+
+} } }
+# 14 "/usr/include/boost-1_42/boost/numeric/conversion/bounds.hpp" 2
+
+namespace boost { namespace numeric
+{
+
+template<class N>
+struct bounds : boundsdetail::get_impl<N>::type
+{} ;
+
+} }
+# 18 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp" 2
+
+
+
+
+
+namespace boost { namespace numeric { namespace convdetail
+{
+
+  typedef mpl::integral_c<std::float_round_style, std::round_toward_zero> round2zero_c ;
+  typedef mpl::integral_c<std::float_round_style, std::round_to_nearest> round2nearest_c ;
+  typedef mpl::integral_c<std::float_round_style, std::round_toward_infinity> round2inf_c ;
+  typedef mpl::integral_c<std::float_round_style, std::round_toward_neg_infinity> round2neg_inf_c ;
+# 40 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+  template<class RoundStyle,class RoundToZero,class RoundToNearest,class RoundToInf,class RoundToNegInf>
+  struct for_round_style
+  {
+    typedef ct_switch4<RoundStyle
+                       , round2zero_c, round2nearest_c, round2inf_c
+                       , RoundToZero , RoundToNearest , RoundToInf , RoundToNegInf
+                      > selector ;
+
+    typedef typename selector::type type ;
+  } ;
+# 81 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+  struct non_applicable { typedef mpl::false_ do_apply ; } ;
+  struct applicable { typedef mpl::true_ do_apply ; } ;
+# 96 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+    template<class Traits>
+    struct LT_LoT : applicable
+    {
+      typedef typename Traits::target_type T ;
+      typedef typename Traits::source_type S ;
+      typedef typename Traits::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        return s < static_cast<S>(bounds<T>::lowest()) ? cNegOverflow : cInRange ;
+      }
+    } ;
+
+
+
+    template<class Traits>
+    struct LT_Zero : applicable
+    {
+      typedef typename Traits::source_type S ;
+      typedef typename Traits::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        return s < static_cast<S>(0) ? cNegOverflow : cInRange ;
+      }
+    } ;
+
+
+
+    template<class Traits>
+    struct LE_PrevLoT : applicable
+    {
+      typedef typename Traits::target_type T ;
+      typedef typename Traits::source_type S ;
+      typedef typename Traits::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        return s <= static_cast<S>(bounds<T>::lowest()) - static_cast<S>(1.0)
+                 ? cNegOverflow : cInRange ;
+      }
+    } ;
+
+
+
+    template<class Traits>
+    struct LT_HalfPrevLoT : applicable
+    {
+      typedef typename Traits::target_type T ;
+      typedef typename Traits::source_type S ;
+      typedef typename Traits::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        return s < static_cast<S>(bounds<T>::lowest()) - static_cast<S>(0.5)
+                 ? cNegOverflow : cInRange ;
+      }
+    } ;
+
+
+
+    template<class Traits>
+    struct GT_HiT : applicable
+    {
+      typedef typename Traits::target_type T ;
+      typedef typename Traits::source_type S ;
+      typedef typename Traits::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        return s > static_cast<S>(bounds<T>::highest())
+                 ? cPosOverflow : cInRange ;
+      }
+    } ;
+
+
+
+    template<class Traits>
+    struct GE_SuccHiT : applicable
+    {
+      typedef typename Traits::target_type T ;
+      typedef typename Traits::source_type S ;
+      typedef typename Traits::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(1.0)
+                 ? cPosOverflow : cInRange ;
+      }
+    } ;
+
+
+
+    template<class Traits>
+    struct GT_HalfSuccHiT : applicable
+    {
+      typedef typename Traits::target_type T ;
+      typedef typename Traits::source_type S ;
+      typedef typename Traits::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(0.5)
+                 ? cPosOverflow : cInRange ;
+      }
+    } ;
+# 215 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+    template<class PredA, class PredB>
+    struct applyBoth
+    {
+      typedef typename PredA::argument_type argument_type ;
+
+      static range_check_result apply ( argument_type s )
+      {
+        range_check_result r = PredA::apply(s) ;
+        if ( r == cInRange )
+          r = PredB::apply(s);
+        return r ;
+      }
+    } ;
+
+    template<class PredA, class PredB>
+    struct combine
+    {
+      typedef applyBoth<PredA,PredB> Both ;
+      typedef void NNone ;
+
+      typedef typename PredA::do_apply do_applyA ;
+      typedef typename PredB::do_apply do_applyB ;
+
+      typedef typename for_both<do_applyA, do_applyB, Both, PredA, PredB, NNone>::type type ;
+    } ;
+# 262 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+  template<class Traits>
+  struct dummy_range_checker
+  {
+    typedef typename Traits::argument_type argument_type ;
+
+    static range_check_result out_of_range ( argument_type ) { return cInRange ; }
+    static void validate_range ( argument_type ) {}
+  } ;
+# 279 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+  template<class Traits, class IsNegOverflow, class IsPosOverflow, class OverflowHandler>
+  struct generic_range_checker
+  {
+    typedef OverflowHandler overflow_handler ;
+
+    typedef typename Traits::argument_type argument_type ;
+
+    static range_check_result out_of_range ( argument_type s )
+    {
+      typedef typename combine<IsNegOverflow,IsPosOverflow>::type Predicate ;
+
+      return Predicate::apply(s);
+    }
+
+    static void validate_range ( argument_type s )
+      { OverflowHandler()( out_of_range(s) ) ; }
+  } ;
+# 305 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+  template<class Traits,class OverflowHandler>
+  struct GetRC_Sig2Sig_or_Unsig2Unsig
+  {
+    typedef dummy_range_checker<Traits> Dummy ;
+
+    typedef LT_LoT<Traits> Pred1 ;
+    typedef GT_HiT<Traits> Pred2 ;
+
+    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;
+
+    typedef typename Traits::subranged subranged ;
+
+    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
+  } ;
+
+  template<class Traits, class OverflowHandler>
+  struct GetRC_Sig2Unsig
+  {
+    typedef LT_Zero<Traits> Pred1 ;
+    typedef GT_HiT <Traits> Pred2 ;
+
+    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ChoiceA ;
+
+    typedef generic_range_checker<Traits,Pred1,non_applicable,OverflowHandler> ChoiceB ;
+
+    typedef typename Traits::target_type T ;
+    typedef typename Traits::source_type S ;
+
+    typedef typename subranged_Unsig2Sig<S,T>::type oposite_subranged ;
+
+    typedef typename mpl::not_<oposite_subranged>::type positively_subranged ;
+
+    typedef typename mpl::if_<positively_subranged,ChoiceA,ChoiceB>::type type ;
+  } ;
+
+  template<class Traits, class OverflowHandler>
+  struct GetRC_Unsig2Sig
+  {
+    typedef GT_HiT<Traits> Pred1 ;
+
+    typedef generic_range_checker<Traits,non_applicable,Pred1,OverflowHandler> type ;
+  } ;
+
+  template<class Traits,class OverflowHandler>
+  struct GetRC_Int2Int
+  {
+    typedef GetRC_Sig2Sig_or_Unsig2Unsig<Traits,OverflowHandler> Sig2SigQ ;
+    typedef GetRC_Sig2Unsig <Traits,OverflowHandler> Sig2UnsigQ ;
+    typedef GetRC_Unsig2Sig <Traits,OverflowHandler> Unsig2SigQ ;
+    typedef Sig2SigQ Unsig2UnsigQ ;
+
+    typedef typename Traits::sign_mixture sign_mixture ;
+
+    typedef typename
+      for_sign_mixture<sign_mixture,Sig2SigQ,Sig2UnsigQ,Unsig2SigQ,Unsig2UnsigQ>::type
+        selector ;
+
+    typedef typename selector::type type ;
+  } ;
+
+  template<class Traits>
+  struct GetRC_Int2Float
+  {
+    typedef dummy_range_checker<Traits> type ;
+  } ;
+
+  template<class Traits, class OverflowHandler, class Float2IntRounder>
+  struct GetRC_Float2Int
+  {
+    typedef LE_PrevLoT <Traits> Pred1 ;
+    typedef GE_SuccHiT <Traits> Pred2 ;
+    typedef LT_HalfPrevLoT<Traits> Pred3 ;
+    typedef GT_HalfSuccHiT<Traits> Pred4 ;
+    typedef GT_HiT <Traits> Pred5 ;
+    typedef LT_LoT <Traits> Pred6 ;
+
+    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ToZero ;
+    typedef generic_range_checker<Traits,Pred3,Pred4,OverflowHandler> ToNearest ;
+    typedef generic_range_checker<Traits,Pred1,Pred5,OverflowHandler> ToInf ;
+    typedef generic_range_checker<Traits,Pred6,Pred2,OverflowHandler> ToNegInf ;
+
+    typedef typename Float2IntRounder::round_style round_style ;
+
+    typedef typename for_round_style<round_style,ToZero,ToNearest,ToInf,ToNegInf>::type type ;
+  } ;
+
+  template<class Traits, class OverflowHandler>
+  struct GetRC_Float2Float
+  {
+    typedef dummy_range_checker<Traits> Dummy ;
+
+    typedef LT_LoT<Traits> Pred1 ;
+    typedef GT_HiT<Traits> Pred2 ;
+
+    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;
+
+    typedef typename Traits::subranged subranged ;
+
+    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
+  } ;
+
+  template<class Traits, class OverflowHandler, class Float2IntRounder>
+  struct GetRC_BuiltIn2BuiltIn
+  {
+    typedef GetRC_Int2Int<Traits,OverflowHandler> Int2IntQ ;
+    typedef GetRC_Int2Float<Traits> Int2FloatQ ;
+    typedef GetRC_Float2Int<Traits,OverflowHandler,Float2IntRounder> Float2IntQ ;
+    typedef GetRC_Float2Float<Traits,OverflowHandler> Float2FloatQ ;
+
+    typedef typename Traits::int_float_mixture int_float_mixture ;
+
+    typedef typename for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ>::type selector ;
+
+    typedef typename selector::type type ;
+  } ;
+
+  template<class Traits, class OverflowHandler, class Float2IntRounder>
+  struct GetRC
+  {
+    typedef GetRC_BuiltIn2BuiltIn<Traits,OverflowHandler,Float2IntRounder> BuiltIn2BuiltInQ ;
+
+    typedef dummy_range_checker<Traits> Dummy ;
+
+    typedef mpl::identity<Dummy> DummyQ ;
+
+    typedef typename Traits::udt_builtin_mixture udt_builtin_mixture ;
+
+    typedef typename for_udt_builtin_mixture<udt_builtin_mixture,BuiltIn2BuiltInQ,DummyQ,DummyQ,DummyQ>::type selector ;
+
+    typedef typename selector::type type ;
+  } ;
+# 452 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+  template<class Traits>
+  struct trivial_converter_impl : public std::unary_function< typename Traits::argument_type
+                                                              ,typename Traits::result_type
+                                                            >
+                                 ,public dummy_range_checker<Traits>
+  {
+    typedef Traits traits ;
+
+    typedef typename Traits::source_type source_type ;
+    typedef typename Traits::argument_type argument_type ;
+    typedef typename Traits::result_type result_type ;
+
+    static result_type low_level_convert ( argument_type s ) { return s ; }
+    static source_type nearbyint ( argument_type s ) { return s ; }
+    static result_type convert ( argument_type s ) { return s ; }
+  } ;
+
+
+
+
+
+  template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder>
+  struct rounding_converter : public std::unary_function< typename Traits::argument_type
+                                                          ,typename Traits::result_type
+                                                        >
+                             ,public RangeChecker
+                             ,public Float2IntRounder
+                             ,public RawConverter
+  {
+    typedef RangeChecker RangeCheckerBase ;
+    typedef Float2IntRounder Float2IntRounderBase ;
+    typedef RawConverter RawConverterBase ;
+
+    typedef Traits traits ;
+
+    typedef typename Traits::source_type source_type ;
+    typedef typename Traits::argument_type argument_type ;
+    typedef typename Traits::result_type result_type ;
+
+    static result_type convert ( argument_type s )
+    {
+      RangeCheckerBase::validate_range(s);
+      source_type s1 = Float2IntRounderBase::nearbyint(s);
+      return RawConverterBase::low_level_convert(s1);
+    }
+  } ;
+
+
+
+
+
+  template<class Traits,class RangeChecker,class RawConverter>
+  struct non_rounding_converter : public std::unary_function< typename Traits::argument_type
+                                                             ,typename Traits::result_type
+                                                           >
+                                 ,public RangeChecker
+                                 ,public RawConverter
+  {
+    typedef RangeChecker RangeCheckerBase ;
+    typedef RawConverter RawConverterBase ;
+
+    typedef Traits traits ;
+
+    typedef typename Traits::source_type source_type ;
+    typedef typename Traits::argument_type argument_type ;
+    typedef typename Traits::result_type result_type ;
+
+    static source_type nearbyint ( argument_type s ) { return s ; }
+
+    static result_type convert ( argument_type s )
+    {
+      RangeCheckerBase::validate_range(s);
+      return RawConverterBase::low_level_convert(s);
+    }
+  } ;
+# 537 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+  template<class Traits,class OverflowHandler,class Float2IntRounder,class RawConverter, class UserRangeChecker>
+  struct get_non_trivial_converter
+  {
+    typedef GetRC<Traits,OverflowHandler,Float2IntRounder> InternalRangeCheckerQ ;
+
+    typedef is_same<UserRangeChecker,UseInternalRangeChecker> use_internal_RC ;
+
+    typedef mpl::identity<UserRangeChecker> UserRangeCheckerQ ;
+
+    typedef typename
+      mpl::eval_if<use_internal_RC,InternalRangeCheckerQ,UserRangeCheckerQ>::type
+        RangeChecker ;
+
+    typedef non_rounding_converter<Traits,RangeChecker,RawConverter> NonRounding ;
+    typedef rounding_converter<Traits,RangeChecker,RawConverter,Float2IntRounder> Rounding ;
+
+    typedef mpl::identity<NonRounding> NonRoundingQ ;
+    typedef mpl::identity<Rounding> RoundingQ ;
+
+    typedef typename Traits::int_float_mixture int_float_mixture ;
+
+    typedef typename
+      for_int_float_mixture<int_float_mixture, NonRoundingQ, NonRoundingQ, RoundingQ, NonRoundingQ>::type
+        selector ;
+
+    typedef typename selector::type type ;
+  } ;
+
+  template< class Traits
+           ,class OverflowHandler
+           ,class Float2IntRounder
+           ,class RawConverter
+           ,class UserRangeChecker
+          >
+  struct get_converter_impl
+  {
+# 583 "/usr/include/boost-1_42/boost/numeric/conversion/detail/converter.hpp"
+    typedef trivial_converter_impl<Traits> Trivial ;
+    typedef mpl::identity <Trivial> TrivialQ ;
+
+    typedef get_non_trivial_converter< Traits
+                                      ,OverflowHandler
+                                      ,Float2IntRounder
+                                      ,RawConverter
+                                      ,UserRangeChecker
+                                     > NonTrivialQ ;
+
+    typedef typename Traits::trivial trivial ;
+
+    typedef typename mpl::eval_if<trivial,TrivialQ,NonTrivialQ>::type type ;
+  } ;
+
+} } }
+# 17 "/usr/include/boost-1_42/boost/numeric/conversion/converter.hpp" 2
+
+namespace boost { namespace numeric
+{
+
+template<class T,
+         class S,
+         class Traits = conversion_traits<T,S>,
+         class OverflowHandler = def_overflow_handler,
+         class Float2IntRounder = Trunc< typename Traits::source_type> ,
+         class RawConverter = raw_converter<Traits>,
+         class UserRangeChecker = UseInternalRangeChecker
+        >
+struct converter : convdetail::get_converter_impl<Traits,
+                                                  OverflowHandler,
+                                                  Float2IntRounder,
+                                                  RawConverter,
+                                                  UserRangeChecker
+                                                 >::type
+{
+  typedef Traits traits ;
+
+  typedef typename Traits::argument_type argument_type ;
+  typedef typename Traits::result_type result_type ;
+
+  result_type operator() ( argument_type s ) const { return this->convert(s) ; }
+} ;
+
+
+
+template<class S,
+         class OverflowHandler = def_overflow_handler,
+         class Float2IntRounder = Trunc<S> ,
+         class UserRangeChecker = UseInternalRangeChecker
+        >
+struct make_converter_from
+{
+  template<class T,
+           class Traits = conversion_traits<T,S>,
+           class RawConverter = raw_converter<Traits>
+          >
+  struct to
+  {
+    typedef converter<T,S,Traits,OverflowHandler,Float2IntRounder,RawConverter,UserRangeChecker> type ;
+  } ;
+
+} ;
+
+} }
+# 33 "/usr/include/boost-1_42/boost/numeric/conversion/cast.hpp" 2
+
+namespace boost
+{
+  template<typename Target, typename Source>
+  inline
+  Target numeric_cast ( Source arg )
+  {
+    typedef boost::numeric::converter<Target,Source> Converter ;
+    return Converter::convert(arg);
+  }
+
+  using numeric::bad_numeric_cast;
+
+}
+# 14 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 1 3
+# 58 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 3
+       
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 3
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 1 3
+# 67 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 85 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+  enum _Rb_tree_color { _S_red = false, _S_black = true };
+
+  struct _Rb_tree_node_base
+  {
+    typedef _Rb_tree_node_base* _Base_ptr;
+    typedef const _Rb_tree_node_base* _Const_Base_ptr;
+
+    _Rb_tree_color _M_color;
+    _Base_ptr _M_parent;
+    _Base_ptr _M_left;
+    _Base_ptr _M_right;
+
+    static _Base_ptr
+    _S_minimum(_Base_ptr __x)
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+
+    static _Const_Base_ptr
+    _S_minimum(_Const_Base_ptr __x)
+    {
+      while (__x->_M_left != 0) __x = __x->_M_left;
+      return __x;
+    }
+
+    static _Base_ptr
+    _S_maximum(_Base_ptr __x)
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+
+    static _Const_Base_ptr
+    _S_maximum(_Const_Base_ptr __x)
+    {
+      while (__x->_M_right != 0) __x = __x->_M_right;
+      return __x;
+    }
+  };
+
+  template<typename _Val>
+    struct _Rb_tree_node : public _Rb_tree_node_base
+    {
+      typedef _Rb_tree_node<_Val>* _Link_type;
+      _Val _M_value_field;
+
+
+
+
+
+
+
+    };
+
+  __attribute__ ((__pure__)) _Rb_tree_node_base*
+  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();
+
+  __attribute__ ((__pure__)) const _Rb_tree_node_base*
+  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();
+
+  __attribute__ ((__pure__)) _Rb_tree_node_base*
+  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();
+
+  __attribute__ ((__pure__)) const _Rb_tree_node_base*
+  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();
+
+  template<typename _Tp>
+    struct _Rb_tree_iterator
+    {
+      typedef _Tp value_type;
+      typedef _Tp& reference;
+      typedef _Tp* pointer;
+
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t difference_type;
+
+      typedef _Rb_tree_iterator<_Tp> _Self;
+      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
+      typedef _Rb_tree_node<_Tp>* _Link_type;
+
+      _Rb_tree_iterator()
+      : _M_node() { }
+
+      explicit
+      _Rb_tree_iterator(_Link_type __x)
+      : _M_node(__x) { }
+
+      reference
+      operator*() const
+      { return static_cast<_Link_type>(_M_node)->_M_value_field; }
+
+      pointer
+      operator->() const
+      { return &static_cast<_Link_type>(_M_node)->_M_value_field; }
+
+      _Self&
+      operator++()
+      {
+ _M_node = _Rb_tree_increment(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_increment(_M_node);
+ return __tmp;
+      }
+
+      _Self&
+      operator--()
+      {
+ _M_node = _Rb_tree_decrement(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_decrement(_M_node);
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+
+      _Base_ptr _M_node;
+  };
+
+  template<typename _Tp>
+    struct _Rb_tree_const_iterator
+    {
+      typedef _Tp value_type;
+      typedef const _Tp& reference;
+      typedef const _Tp* pointer;
+
+      typedef _Rb_tree_iterator<_Tp> iterator;
+
+      typedef bidirectional_iterator_tag iterator_category;
+      typedef ptrdiff_t difference_type;
+
+      typedef _Rb_tree_const_iterator<_Tp> _Self;
+      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
+      typedef const _Rb_tree_node<_Tp>* _Link_type;
+
+      _Rb_tree_const_iterator()
+      : _M_node() { }
+
+      explicit
+      _Rb_tree_const_iterator(_Link_type __x)
+      : _M_node(__x) { }
+
+      _Rb_tree_const_iterator(const iterator& __it)
+      : _M_node(__it._M_node) { }
+
+      reference
+      operator*() const
+      { return static_cast<_Link_type>(_M_node)->_M_value_field; }
+
+      pointer
+      operator->() const
+      { return &static_cast<_Link_type>(_M_node)->_M_value_field; }
+
+      _Self&
+      operator++()
+      {
+ _M_node = _Rb_tree_increment(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator++(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_increment(_M_node);
+ return __tmp;
+      }
+
+      _Self&
+      operator--()
+      {
+ _M_node = _Rb_tree_decrement(_M_node);
+ return *this;
+      }
+
+      _Self
+      operator--(int)
+      {
+ _Self __tmp = *this;
+ _M_node = _Rb_tree_decrement(_M_node);
+ return __tmp;
+      }
+
+      bool
+      operator==(const _Self& __x) const
+      { return _M_node == __x._M_node; }
+
+      bool
+      operator!=(const _Self& __x) const
+      { return _M_node != __x._M_node; }
+
+      _Base_ptr _M_node;
+    };
+
+  template<typename _Val>
+    inline bool
+    operator==(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y)
+    { return __x._M_node == __y._M_node; }
+
+  template<typename _Val>
+    inline bool
+    operator!=(const _Rb_tree_iterator<_Val>& __x,
+               const _Rb_tree_const_iterator<_Val>& __y)
+    { return __x._M_node != __y._M_node; }
+
+  void
+  _Rb_tree_insert_and_rebalance(const bool __insert_left,
+                                _Rb_tree_node_base* __x,
+                                _Rb_tree_node_base* __p,
+                                _Rb_tree_node_base& __header) throw ();
+
+  _Rb_tree_node_base*
+  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
+          _Rb_tree_node_base& __header) throw ();
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc = allocator<_Val> >
+    class _Rb_tree
+    {
+      typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other
+              _Node_allocator;
+
+    protected:
+      typedef _Rb_tree_node_base* _Base_ptr;
+      typedef const _Rb_tree_node_base* _Const_Base_ptr;
+
+    public:
+      typedef _Key key_type;
+      typedef _Val value_type;
+      typedef value_type* pointer;
+      typedef const value_type* const_pointer;
+      typedef value_type& reference;
+      typedef const value_type& const_reference;
+      typedef _Rb_tree_node<_Val>* _Link_type;
+      typedef const _Rb_tree_node<_Val>* _Const_Link_type;
+      typedef size_t size_type;
+      typedef ptrdiff_t difference_type;
+      typedef _Alloc allocator_type;
+
+      _Node_allocator&
+      _M_get_Node_allocator()
+      { return *static_cast<_Node_allocator*>(&this->_M_impl); }
+
+      const _Node_allocator&
+      _M_get_Node_allocator() const
+      { return *static_cast<const _Node_allocator*>(&this->_M_impl); }
+
+      allocator_type
+      get_allocator() const
+      { return allocator_type(_M_get_Node_allocator()); }
+
+    protected:
+      _Link_type
+      _M_get_node()
+      { return _M_impl._Node_allocator::allocate(1); }
+
+      void
+      _M_put_node(_Link_type __p)
+      { _M_impl._Node_allocator::deallocate(__p, 1); }
+
+
+      _Link_type
+      _M_create_node(const value_type& __x)
+      {
+ _Link_type __tmp = _M_get_node();
+ try
+   { get_allocator().construct(&__tmp->_M_value_field, __x); }
+ catch(...)
+   {
+     _M_put_node(__tmp);
+     throw;
+   }
+ return __tmp;
+      }
+
+      void
+      _M_destroy_node(_Link_type __p)
+      {
+ get_allocator().destroy(&__p->_M_value_field);
+ _M_put_node(__p);
+      }
+# 413 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+      _Link_type
+      _M_clone_node(_Const_Link_type __x)
+      {
+ _Link_type __tmp = _M_create_node(__x->_M_value_field);
+ __tmp->_M_color = __x->_M_color;
+ __tmp->_M_left = 0;
+ __tmp->_M_right = 0;
+ return __tmp;
+      }
+
+    protected:
+      template<typename _Key_compare,
+        bool _Is_pod_comparator = __is_pod(_Key_compare)>
+        struct _Rb_tree_impl : public _Node_allocator
+        {
+   _Key_compare _M_key_compare;
+   _Rb_tree_node_base _M_header;
+   size_type _M_node_count;
+
+   _Rb_tree_impl()
+   : _Node_allocator(), _M_key_compare(), _M_header(),
+     _M_node_count(0)
+   { _M_initialize(); }
+
+   _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a)
+   : _Node_allocator(__a), _M_key_compare(__comp), _M_header(),
+     _M_node_count(0)
+   { _M_initialize(); }
+
+ private:
+   void
+   _M_initialize()
+   {
+     this->_M_header._M_color = _S_red;
+     this->_M_header._M_parent = 0;
+     this->_M_header._M_left = &this->_M_header;
+     this->_M_header._M_right = &this->_M_header;
+   }
+ };
+
+      _Rb_tree_impl<_Compare> _M_impl;
+
+    protected:
+      _Base_ptr&
+      _M_root()
+      { return this->_M_impl._M_header._M_parent; }
+
+      _Const_Base_ptr
+      _M_root() const
+      { return this->_M_impl._M_header._M_parent; }
+
+      _Base_ptr&
+      _M_leftmost()
+      { return this->_M_impl._M_header._M_left; }
+
+      _Const_Base_ptr
+      _M_leftmost() const
+      { return this->_M_impl._M_header._M_left; }
+
+      _Base_ptr&
+      _M_rightmost()
+      { return this->_M_impl._M_header._M_right; }
+
+      _Const_Base_ptr
+      _M_rightmost() const
+      { return this->_M_impl._M_header._M_right; }
+
+      _Link_type
+      _M_begin()
+      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }
+
+      _Const_Link_type
+      _M_begin() const
+      {
+ return static_cast<_Const_Link_type>
+   (this->_M_impl._M_header._M_parent);
+      }
+
+      _Link_type
+      _M_end()
+      { return static_cast<_Link_type>(&this->_M_impl._M_header); }
+
+      _Const_Link_type
+      _M_end() const
+      { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); }
+
+      static const_reference
+      _S_value(_Const_Link_type __x)
+      { return __x->_M_value_field; }
+
+      static const _Key&
+      _S_key(_Const_Link_type __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+
+      static _Link_type
+      _S_left(_Base_ptr __x)
+      { return static_cast<_Link_type>(__x->_M_left); }
+
+      static _Const_Link_type
+      _S_left(_Const_Base_ptr __x)
+      { return static_cast<_Const_Link_type>(__x->_M_left); }
+
+      static _Link_type
+      _S_right(_Base_ptr __x)
+      { return static_cast<_Link_type>(__x->_M_right); }
+
+      static _Const_Link_type
+      _S_right(_Const_Base_ptr __x)
+      { return static_cast<_Const_Link_type>(__x->_M_right); }
+
+      static const_reference
+      _S_value(_Const_Base_ptr __x)
+      { return static_cast<_Const_Link_type>(__x)->_M_value_field; }
+
+      static const _Key&
+      _S_key(_Const_Base_ptr __x)
+      { return _KeyOfValue()(_S_value(__x)); }
+
+      static _Base_ptr
+      _S_minimum(_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+
+      static _Const_Base_ptr
+      _S_minimum(_Const_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_minimum(__x); }
+
+      static _Base_ptr
+      _S_maximum(_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+
+      static _Const_Base_ptr
+      _S_maximum(_Const_Base_ptr __x)
+      { return _Rb_tree_node_base::_S_maximum(__x); }
+
+    public:
+      typedef _Rb_tree_iterator<value_type> iterator;
+      typedef _Rb_tree_const_iterator<value_type> const_iterator;
+
+      typedef std::reverse_iterator<iterator> reverse_iterator;
+      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    private:
+      iterator
+      _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __y,
+   const value_type& __v);
+
+
+
+      iterator
+      _M_insert_lower(_Base_ptr __x, _Base_ptr __y, const value_type& __v);
+
+      iterator
+      _M_insert_equal_lower(const value_type& __x);
+
+      _Link_type
+      _M_copy(_Const_Link_type __x, _Link_type __p);
+
+      void
+      _M_erase(_Link_type __x);
+
+      iterator
+      _M_lower_bound(_Link_type __x, _Link_type __y,
+       const _Key& __k);
+
+      const_iterator
+      _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+       const _Key& __k) const;
+
+      iterator
+      _M_upper_bound(_Link_type __x, _Link_type __y,
+       const _Key& __k);
+
+      const_iterator
+      _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+       const _Key& __k) const;
+
+    public:
+
+      _Rb_tree() { }
+
+      _Rb_tree(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_impl(__comp, __a) { }
+
+      _Rb_tree(const _Rb_tree& __x)
+      : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator())
+      {
+ if (__x._M_root() != 0)
+   {
+     _M_root() = _M_copy(__x._M_begin(), _M_end());
+     _M_leftmost() = _S_minimum(_M_root());
+     _M_rightmost() = _S_maximum(_M_root());
+     _M_impl._M_node_count = __x._M_impl._M_node_count;
+   }
+      }
+
+
+
+
+
+      ~_Rb_tree()
+      { _M_erase(_M_begin()); }
+
+      _Rb_tree&
+      operator=(const _Rb_tree& __x);
+
+
+      _Compare
+      key_comp() const
+      { return _M_impl._M_key_compare; }
+
+      iterator
+      begin()
+      {
+ return iterator(static_cast<_Link_type>
+   (this->_M_impl._M_header._M_left));
+      }
+
+      const_iterator
+      begin() const
+      {
+ return const_iterator(static_cast<_Const_Link_type>
+         (this->_M_impl._M_header._M_left));
+      }
+
+      iterator
+      end()
+      { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); }
+
+      const_iterator
+      end() const
+      {
+ return const_iterator(static_cast<_Const_Link_type>
+         (&this->_M_impl._M_header));
+      }
+
+      reverse_iterator
+      rbegin()
+      { return reverse_iterator(end()); }
+
+      const_reverse_iterator
+      rbegin() const
+      { return const_reverse_iterator(end()); }
+
+      reverse_iterator
+      rend()
+      { return reverse_iterator(begin()); }
+
+      const_reverse_iterator
+      rend() const
+      { return const_reverse_iterator(begin()); }
+
+      bool
+      empty() const
+      { return _M_impl._M_node_count == 0; }
+
+      size_type
+      size() const
+      { return _M_impl._M_node_count; }
+
+      size_type
+      max_size() const
+      { return _M_get_Node_allocator().max_size(); }
+
+      void
+      swap(_Rb_tree& __t);
+
+
+      pair<iterator, bool>
+      _M_insert_unique(const value_type& __x);
+
+      iterator
+      _M_insert_equal(const value_type& __x);
+
+      iterator
+      _M_insert_unique_(const_iterator __position, const value_type& __x);
+
+      iterator
+      _M_insert_equal_(const_iterator __position, const value_type& __x);
+
+      template<typename _InputIterator>
+        void
+        _M_insert_unique(_InputIterator __first, _InputIterator __last);
+
+      template<typename _InputIterator>
+        void
+        _M_insert_equal(_InputIterator __first, _InputIterator __last);
+# 712 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+      void
+      erase(iterator __position);
+
+      void
+      erase(const_iterator __position);
+
+      size_type
+      erase(const key_type& __x);
+# 732 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+      void
+      erase(iterator __first, iterator __last);
+
+      void
+      erase(const_iterator __first, const_iterator __last);
+
+      void
+      erase(const key_type* __first, const key_type* __last);
+
+      void
+      clear()
+      {
+        _M_erase(_M_begin());
+        _M_leftmost() = _M_end();
+        _M_root() = 0;
+        _M_rightmost() = _M_end();
+        _M_impl._M_node_count = 0;
+      }
+
+
+      iterator
+      find(const key_type& __k);
+
+      const_iterator
+      find(const key_type& __k) const;
+
+      size_type
+      count(const key_type& __k) const;
+
+      iterator
+      lower_bound(const key_type& __k)
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+
+      const_iterator
+      lower_bound(const key_type& __k) const
+      { return _M_lower_bound(_M_begin(), _M_end(), __k); }
+
+      iterator
+      upper_bound(const key_type& __k)
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+
+      const_iterator
+      upper_bound(const key_type& __k) const
+      { return _M_upper_bound(_M_begin(), _M_end(), __k); }
+
+      pair<iterator, iterator>
+      equal_range(const key_type& __k);
+
+      pair<const_iterator, const_iterator>
+      equal_range(const key_type& __k) const;
+
+
+      bool
+      __rb_verify() const;
+    };
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return __x.size() == __y.size()
+      && std::equal(__x.begin(), __x.end(), __y.begin());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    {
+      return std::lexicographical_compare(__x.begin(), __x.end(),
+       __y.begin(), __y.end());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+       const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+        const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline void
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
+  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+# 867 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x)
+    {
+      if (this != &__x)
+ {
+
+   clear();
+   _M_impl._M_key_compare = __x._M_impl._M_key_compare;
+   if (__x._M_root() != 0)
+     {
+       _M_root() = _M_copy(__x._M_begin(), _M_end());
+       _M_leftmost() = _S_minimum(_M_root());
+       _M_rightmost() = _S_maximum(_M_root());
+       _M_impl._M_node_count = __x._M_impl._M_node_count;
+     }
+ }
+      return *this;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v)
+    {
+      bool __insert_left = (__x != 0 || __p == _M_end()
+       || _M_impl._M_key_compare(_KeyOfValue()(__v),
+            _S_key(__p)));
+
+      _Link_type __z = _M_create_node(__v);
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z,
+        const_cast<_Base_ptr>(__p),
+        this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_lower(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
+    {
+      bool __insert_left = (__x != 0 || __p == _M_end()
+       || !_M_impl._M_key_compare(_S_key(__p),
+             _KeyOfValue()(__v)));
+
+      _Link_type __z = _M_create_node(__v);
+
+      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
+        this->_M_impl._M_header);
+      ++_M_impl._M_node_count;
+      return iterator(__z);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal_lower(const _Val& __v)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   __y = __x;
+   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
+         _S_left(__x) : _S_right(__x);
+ }
+      return _M_insert_lower(__x, __y, __v);
+    }
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
+    _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
+    _M_copy(_Const_Link_type __x, _Link_type __p)
+    {
+
+      _Link_type __top = _M_clone_node(__x);
+      __top->_M_parent = __p;
+
+      try
+ {
+   if (__x->_M_right)
+     __top->_M_right = _M_copy(_S_right(__x), __top);
+   __p = __top;
+   __x = _S_left(__x);
+
+   while (__x != 0)
+     {
+       _Link_type __y = _M_clone_node(__x);
+       __p->_M_left = __y;
+       __y->_M_parent = __p;
+       if (__x->_M_right)
+  __y->_M_right = _M_copy(_S_right(__x), __y);
+       __p = __y;
+       __x = _S_left(__x);
+     }
+ }
+      catch(...)
+ {
+   _M_erase(__top);
+   throw;
+ }
+      return __top;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_erase(_Link_type __x)
+    {
+
+      while (__x != 0)
+ {
+   _M_erase(_S_right(__x));
+   _Link_type __y = _S_left(__x);
+   _M_destroy_node(__x);
+   __x = __y;
+ }
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Link_type __x, _Link_type __y,
+     const _Key& __k)
+    {
+      while (__x != 0)
+ if (!_M_impl._M_key_compare(_S_key(__x), __k))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y,
+     const _Key& __k) const
+    {
+      while (__x != 0)
+ if (!_M_impl._M_key_compare(_S_key(__x), __k))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Link_type __x, _Link_type __y,
+     const _Key& __k)
+    {
+      while (__x != 0)
+ if (_M_impl._M_key_compare(__k, _S_key(__x)))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y,
+     const _Key& __k) const
+    {
+      while (__x != 0)
+ if (_M_impl._M_key_compare(__k, _S_key(__x)))
+   __y = __x, __x = _S_left(__x);
+ else
+   __x = _S_right(__x);
+      return const_iterator(__y);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   if (_M_impl._M_key_compare(_S_key(__x), __k))
+     __x = _S_right(__x);
+   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+     __y = __x, __x = _S_left(__x);
+   else
+     {
+       _Link_type __xu(__x), __yu(__y);
+       __y = __x, __x = _S_left(__x);
+       __xu = _S_right(__xu);
+       return pair<iterator,
+            iterator>(_M_lower_bound(__x, __y, __k),
+        _M_upper_bound(__xu, __yu, __k));
+     }
+ }
+      return pair<iterator, iterator>(iterator(__y),
+          iterator(__y));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::const_iterator,
+  typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::const_iterator>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    equal_range(const _Key& __k) const
+    {
+      _Const_Link_type __x = _M_begin();
+      _Const_Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   if (_M_impl._M_key_compare(_S_key(__x), __k))
+     __x = _S_right(__x);
+   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
+     __y = __x, __x = _S_left(__x);
+   else
+     {
+       _Const_Link_type __xu(__x), __yu(__y);
+       __y = __x, __x = _S_left(__x);
+       __xu = _S_right(__xu);
+       return pair<const_iterator,
+            const_iterator>(_M_lower_bound(__x, __y, __k),
+       _M_upper_bound(__xu, __yu, __k));
+     }
+ }
+      return pair<const_iterator, const_iterator>(const_iterator(__y),
+        const_iterator(__y));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t)
+    {
+      if (_M_root() == 0)
+ {
+   if (__t._M_root() != 0)
+     {
+       _M_root() = __t._M_root();
+       _M_leftmost() = __t._M_leftmost();
+       _M_rightmost() = __t._M_rightmost();
+       _M_root()->_M_parent = _M_end();
+
+       __t._M_root() = 0;
+       __t._M_leftmost() = __t._M_end();
+       __t._M_rightmost() = __t._M_end();
+     }
+ }
+      else if (__t._M_root() == 0)
+ {
+   __t._M_root() = _M_root();
+   __t._M_leftmost() = _M_leftmost();
+   __t._M_rightmost() = _M_rightmost();
+   __t._M_root()->_M_parent = __t._M_end();
+
+   _M_root() = 0;
+   _M_leftmost() = _M_end();
+   _M_rightmost() = _M_end();
+ }
+      else
+ {
+   std::swap(_M_root(),__t._M_root());
+   std::swap(_M_leftmost(),__t._M_leftmost());
+   std::swap(_M_rightmost(),__t._M_rightmost());
+
+   _M_root()->_M_parent = _M_end();
+   __t._M_root()->_M_parent = __t._M_end();
+ }
+
+      std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
+      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);
+
+
+
+      std::__alloc_swap<_Node_allocator>::
+ _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator());
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
+      _Compare, _Alloc>::iterator, bool>
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_unique(const _Val& __v)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      bool __comp = true;
+      while (__x != 0)
+ {
+   __y = __x;
+   __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
+   __x = __comp ? _S_left(__x) : _S_right(__x);
+ }
+      iterator __j = iterator(__y);
+      if (__comp)
+ {
+   if (__j == begin())
+     return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
+   else
+     --__j;
+ }
+      if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
+ return pair<iterator, bool>(_M_insert_(__x, __y, __v), true);
+      return pair<iterator, bool>(__j, false);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal(const _Val& __v)
+    {
+      _Link_type __x = _M_begin();
+      _Link_type __y = _M_end();
+      while (__x != 0)
+ {
+   __y = __x;
+   __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ?
+         _S_left(__x) : _S_right(__x);
+ }
+      return _M_insert_(__x, __y, __v);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_unique_(const_iterator __position, const _Val& __v)
+    {
+
+      if (__position._M_node == _M_end())
+ {
+   if (size() > 0
+       && _M_impl._M_key_compare(_S_key(_M_rightmost()),
+     _KeyOfValue()(__v)))
+     return _M_insert_(0, _M_rightmost(), __v);
+   else
+     return _M_insert_unique(__v).first;
+ }
+      else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
+          _S_key(__position._M_node)))
+ {
+
+   const_iterator __before = __position;
+   if (__position._M_node == _M_leftmost())
+     return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
+   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node),
+       _KeyOfValue()(__v)))
+     {
+       if (_S_right(__before._M_node) == 0)
+  return _M_insert_(0, __before._M_node, __v);
+       else
+  return _M_insert_(__position._M_node,
+      __position._M_node, __v);
+     }
+   else
+     return _M_insert_unique(__v).first;
+ }
+      else if (_M_impl._M_key_compare(_S_key(__position._M_node),
+          _KeyOfValue()(__v)))
+ {
+
+   const_iterator __after = __position;
+   if (__position._M_node == _M_rightmost())
+     return _M_insert_(0, _M_rightmost(), __v);
+   else if (_M_impl._M_key_compare(_KeyOfValue()(__v),
+       _S_key((++__after)._M_node)))
+     {
+       if (_S_right(__position._M_node) == 0)
+  return _M_insert_(0, __position._M_node, __v);
+       else
+  return _M_insert_(__after._M_node, __after._M_node, __v);
+     }
+   else
+     return _M_insert_unique(__v).first;
+ }
+      else
+
+ return iterator(static_cast<_Link_type>
+   (const_cast<_Base_ptr>(__position._M_node)));
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    _M_insert_equal_(const_iterator __position, const _Val& __v)
+    {
+
+      if (__position._M_node == _M_end())
+ {
+   if (size() > 0
+       && !_M_impl._M_key_compare(_KeyOfValue()(__v),
+      _S_key(_M_rightmost())))
+     return _M_insert_(0, _M_rightmost(), __v);
+   else
+     return _M_insert_equal(__v);
+ }
+      else if (!_M_impl._M_key_compare(_S_key(__position._M_node),
+           _KeyOfValue()(__v)))
+ {
+
+   const_iterator __before = __position;
+   if (__position._M_node == _M_leftmost())
+     return _M_insert_(_M_leftmost(), _M_leftmost(), __v);
+   else if (!_M_impl._M_key_compare(_KeyOfValue()(__v),
+        _S_key((--__before)._M_node)))
+     {
+       if (_S_right(__before._M_node) == 0)
+  return _M_insert_(0, __before._M_node, __v);
+       else
+  return _M_insert_(__position._M_node,
+      __position._M_node, __v);
+     }
+   else
+     return _M_insert_equal(__v);
+ }
+      else
+ {
+
+   const_iterator __after = __position;
+   if (__position._M_node == _M_rightmost())
+     return _M_insert_(0, _M_rightmost(), __v);
+   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node),
+        _KeyOfValue()(__v)))
+     {
+       if (_S_right(__position._M_node) == 0)
+  return _M_insert_(0, __position._M_node, __v);
+       else
+  return _M_insert_(__after._M_node, __after._M_node, __v);
+     }
+   else
+     return _M_insert_equal_lower(__v);
+ }
+    }
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_unique(_II __first, _II __last)
+      {
+ for (; __first != __last; ++__first)
+   _M_insert_unique_(end(), *__first);
+      }
+
+  template<typename _Key, typename _Val, typename _KoV,
+           typename _Cmp, typename _Alloc>
+    template<class _II>
+      void
+      _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>::
+      _M_insert_equal(_II __first, _II __last)
+      {
+ for (; __first != __last; ++__first)
+   _M_insert_equal_(end(), *__first);
+      }
+# 1391 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(iterator __position)
+    {
+      _Link_type __y =
+ static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
+    (__position._M_node,
+     this->_M_impl._M_header));
+      _M_destroy_node(__y);
+      --_M_impl._M_node_count;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    inline void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const_iterator __position)
+    {
+      _Link_type __y =
+ static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
+    (const_cast<_Base_ptr>(__position._M_node),
+     this->_M_impl._M_header));
+      _M_destroy_node(__y);
+      --_M_impl._M_node_count;
+    }
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key& __x)
+    {
+      pair<iterator, iterator> __p = equal_range(__x);
+      const size_type __old_size = size();
+      erase(__p.first, __p.second);
+      return __old_size - size();
+    }
+# 1475 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_tree.h" 3
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(iterator __first, iterator __last)
+    {
+      if (__first == begin() && __last == end())
+ clear();
+      else
+ while (__first != __last)
+   erase(__first++);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const_iterator __first, const_iterator __last)
+    {
+      if (__first == begin() && __last == end())
+ clear();
+      else
+ while (__first != __last)
+   erase(__first++);
+    }
+
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    void
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    erase(const _Key* __first, const _Key* __last)
+    {
+      while (__first != __last)
+ erase(*__first++);
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k)
+    {
+      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+       || _M_impl._M_key_compare(__k,
+     _S_key(__j._M_node))) ? end() : __j;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue,
+        _Compare, _Alloc>::const_iterator
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    find(const _Key& __k) const
+    {
+      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
+      return (__j == end()
+       || _M_impl._M_key_compare(__k,
+     _S_key(__j._M_node))) ? end() : __j;
+    }
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
+    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
+    count(const _Key& __k) const
+    {
+      pair<const_iterator, const_iterator> __p = equal_range(__k);
+      const size_type __n = std::distance(__p.first, __p.second);
+      return __n;
+    }
+
+  __attribute__ ((__pure__)) unsigned int
+  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
+                       const _Rb_tree_node_base* __root) throw ();
+
+  template<typename _Key, typename _Val, typename _KeyOfValue,
+           typename _Compare, typename _Alloc>
+    bool
+    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
+    {
+      if (_M_impl._M_node_count == 0 || begin() == end())
+ return _M_impl._M_node_count == 0 && begin() == end()
+        && this->_M_impl._M_header._M_left == _M_end()
+        && this->_M_impl._M_header._M_right == _M_end();
+
+      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
+      for (const_iterator __it = begin(); __it != end(); ++__it)
+ {
+   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
+   _Const_Link_type __L = _S_left(__x);
+   _Const_Link_type __R = _S_right(__x);
+
+   if (__x->_M_color == _S_red)
+     if ((__L && __L->_M_color == _S_red)
+  || (__R && __R->_M_color == _S_red))
+       return false;
+
+   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
+     return false;
+   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
+     return false;
+
+   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
+     return false;
+ }
+
+      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
+ return false;
+      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
+ return false;
+      return true;
+    }
+
+}
+# 61 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 1 3
+# 64 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 84 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
+            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class map
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+
+    private:
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+     
+     
+
+     
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class map<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+
+ value_compare(_Compare __c)
+ : comp(__c) { }
+
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+
+    private:
+
+      typedef typename _Alloc::template rebind<value_type>::other
+        _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+
+
+      _Rep_type _M_t;
+
+    public:
+
+
+      typedef typename _Pair_alloc_type::pointer pointer;
+      typedef typename _Pair_alloc_type::const_pointer const_pointer;
+      typedef typename _Pair_alloc_type::reference reference;
+      typedef typename _Pair_alloc_type::const_reference const_reference;
+      typedef typename _Rep_type::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+
+
+
+
+
+
+      map()
+      : _M_t() { }
+
+
+
+
+
+
+      explicit
+      map(const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+      : _M_t(__comp, __a) { }
+# 170 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      map(const map& __x)
+      : _M_t(__x._M_t) { }
+# 211 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+        { _M_t._M_insert_unique(__first, __last); }
+# 227 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      template<typename _InputIterator>
+        map(_InputIterator __first, _InputIterator __last,
+     const _Compare& __comp,
+     const allocator_type& __a = allocator_type())
+ : _M_t(__comp, __a)
+        { _M_t._M_insert_unique(__first, __last); }
+# 250 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      map&
+      operator=(const map& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+# 296 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      allocator_type
+      get_allocator() const
+      { return _M_t.get_allocator(); }
+
+
+
+
+
+
+
+      iterator
+      begin()
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      iterator
+      end()
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const
+      { return _M_t.end(); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin()
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      reverse_iterator
+      rend()
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const
+      { return _M_t.rend(); }
+# 415 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      bool
+      empty() const
+      { return _M_t.empty(); }
+
+
+      size_type
+      size() const
+      { return _M_t.size(); }
+
+
+      size_type
+      max_size() const
+      { return _M_t.max_size(); }
+# 442 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      mapped_type&
+      operator[](const key_type& __k)
+      {
+
+
+
+ iterator __i = lower_bound(__k);
+
+ if (__i == end() || key_comp()(__k, (*__i).first))
+          __i = insert(__i, value_type(__k, mapped_type()));
+ return (*__i).second;
+      }
+# 464 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      mapped_type&
+      at(const key_type& __k)
+      {
+ iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+
+      const mapped_type&
+      at(const key_type& __k) const
+      {
+ const_iterator __i = lower_bound(__k);
+ if (__i == end() || key_comp()(__k, (*__i).first))
+   __throw_out_of_range(("map::at"));
+ return (*__i).second;
+      }
+# 499 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      std::pair<iterator, bool>
+      insert(const value_type& __x)
+      { return _M_t._M_insert_unique(__x); }
+# 539 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      iterator
+      insert(iterator __position, const value_type& __x)
+      { return _M_t._M_insert_unique_(__position, __x); }
+# 551 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_unique(__first, __last); }
+# 586 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+# 602 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 636 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+# 652 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      void
+      swap(map& __x)
+      { _M_t.swap(__x._M_t); }
+
+
+
+
+
+
+
+      void
+      clear()
+      { _M_t.clear(); }
+
+
+
+
+
+
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+
+
+
+
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+# 695 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+# 710 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+# 722 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }
+# 737 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+# 752 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+
+
+
+
+
+
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+
+
+
+
+
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+# 791 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+# 810 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const map<_K1, _T1, _C1, _A1>&,
+     const map<_K1, _T1, _C1, _A1>&);
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const map<_K1, _T1, _C1, _A1>&,
+    const map<_K1, _T1, _C1, _A1>&);
+    };
+# 835 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+# 852 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_map.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+              const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x,
+               const map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
+  map<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+}
+# 62 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 2 3
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 1 3
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 83 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+  template <typename _Key, typename _Tp,
+     typename _Compare = std::less<_Key>,
+     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
+    class multimap
+    {
+    public:
+      typedef _Key key_type;
+      typedef _Tp mapped_type;
+      typedef std::pair<const _Key, _Tp> value_type;
+      typedef _Compare key_compare;
+      typedef _Alloc allocator_type;
+
+    private:
+
+      typedef typename _Alloc::value_type _Alloc_value_type;
+     
+     
+
+     
+
+    public:
+      class value_compare
+      : public std::binary_function<value_type, value_type, bool>
+      {
+ friend class multimap<_Key, _Tp, _Compare, _Alloc>;
+      protected:
+ _Compare comp;
+
+ value_compare(_Compare __c)
+ : comp(__c) { }
+
+      public:
+ bool operator()(const value_type& __x, const value_type& __y) const
+ { return comp(__x.first, __y.first); }
+      };
+
+    private:
+
+      typedef typename _Alloc::template rebind<value_type>::other
+        _Pair_alloc_type;
+
+      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
+         key_compare, _Pair_alloc_type> _Rep_type;
+
+      _Rep_type _M_t;
+
+    public:
+
+
+      typedef typename _Pair_alloc_type::pointer pointer;
+      typedef typename _Pair_alloc_type::const_pointer const_pointer;
+      typedef typename _Pair_alloc_type::reference reference;
+      typedef typename _Pair_alloc_type::const_reference const_reference;
+      typedef typename _Rep_type::iterator iterator;
+      typedef typename _Rep_type::const_iterator const_iterator;
+      typedef typename _Rep_type::size_type size_type;
+      typedef typename _Rep_type::difference_type difference_type;
+      typedef typename _Rep_type::reverse_iterator reverse_iterator;
+      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
+
+
+
+
+
+
+      multimap()
+      : _M_t() { }
+
+
+
+
+
+
+      explicit
+      multimap(const _Compare& __comp,
+        const allocator_type& __a = allocator_type())
+      : _M_t(__comp, __a) { }
+# 168 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      multimap(const multimap& __x)
+      : _M_t(__x._M_t) { }
+# 208 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last)
+ : _M_t()
+        { _M_t._M_insert_equal(__first, __last); }
+# 224 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+        multimap(_InputIterator __first, _InputIterator __last,
+   const _Compare& __comp,
+   const allocator_type& __a = allocator_type())
+        : _M_t(__comp, __a)
+        { _M_t._M_insert_equal(__first, __last); }
+# 247 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      multimap&
+      operator=(const multimap& __x)
+      {
+ _M_t = __x._M_t;
+ return *this;
+      }
+# 293 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      allocator_type
+      get_allocator() const
+      { return _M_t.get_allocator(); }
+
+
+
+
+
+
+
+      iterator
+      begin()
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      const_iterator
+      begin() const
+      { return _M_t.begin(); }
+
+
+
+
+
+
+      iterator
+      end()
+      { return _M_t.end(); }
+
+
+
+
+
+
+      const_iterator
+      end() const
+      { return _M_t.end(); }
+
+
+
+
+
+
+      reverse_iterator
+      rbegin()
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rbegin() const
+      { return _M_t.rbegin(); }
+
+
+
+
+
+
+      reverse_iterator
+      rend()
+      { return _M_t.rend(); }
+
+
+
+
+
+
+      const_reverse_iterator
+      rend() const
+      { return _M_t.rend(); }
+# 410 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      bool
+      empty() const
+      { return _M_t.empty(); }
+
+
+      size_type
+      size() const
+      { return _M_t.size(); }
+
+
+      size_type
+      max_size() const
+      { return _M_t.max_size(); }
+# 437 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      iterator
+      insert(const value_type& __x)
+      { return _M_t._M_insert_equal(__x); }
+# 461 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      iterator
+      insert(iterator __position, const value_type& __x)
+      { return _M_t._M_insert_equal_(__position, __x); }
+# 474 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      template<typename _InputIterator>
+        void
+        insert(_InputIterator __first, _InputIterator __last)
+        { _M_t._M_insert_equal(__first, __last); }
+# 522 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      void
+      erase(iterator __position)
+      { _M_t.erase(__position); }
+# 538 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      size_type
+      erase(const key_type& __x)
+      { return _M_t.erase(__x); }
+# 574 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      void
+      erase(iterator __first, iterator __last)
+      { _M_t.erase(__first, __last); }
+# 590 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      void
+      swap(multimap& __x)
+      { _M_t.swap(__x._M_t); }
+
+
+
+
+
+
+
+      void
+      clear()
+      { _M_t.clear(); }
+
+
+
+
+
+
+      key_compare
+      key_comp() const
+      { return _M_t.key_comp(); }
+
+
+
+
+
+      value_compare
+      value_comp() const
+      { return value_compare(_M_t.key_comp()); }
+# 633 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      iterator
+      find(const key_type& __x)
+      { return _M_t.find(__x); }
+# 648 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      const_iterator
+      find(const key_type& __x) const
+      { return _M_t.find(__x); }
+
+
+
+
+
+
+      size_type
+      count(const key_type& __x) const
+      { return _M_t.count(__x); }
+# 672 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      iterator
+      lower_bound(const key_type& __x)
+      { return _M_t.lower_bound(__x); }
+# 687 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      const_iterator
+      lower_bound(const key_type& __x) const
+      { return _M_t.lower_bound(__x); }
+
+
+
+
+
+
+
+      iterator
+      upper_bound(const key_type& __x)
+      { return _M_t.upper_bound(__x); }
+
+
+
+
+
+
+
+      const_iterator
+      upper_bound(const key_type& __x) const
+      { return _M_t.upper_bound(__x); }
+# 724 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      std::pair<iterator, iterator>
+      equal_range(const key_type& __x)
+      { return _M_t.equal_range(__x); }
+# 741 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+      std::pair<const_iterator, const_iterator>
+      equal_range(const key_type& __x) const
+      { return _M_t.equal_range(__x); }
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator==(const multimap<_K1, _T1, _C1, _A1>&,
+     const multimap<_K1, _T1, _C1, _A1>&);
+
+      template<typename _K1, typename _T1, typename _C1, typename _A1>
+        friend bool
+        operator<(const multimap<_K1, _T1, _C1, _A1>&,
+    const multimap<_K1, _T1, _C1, _A1>&);
+  };
+# 766 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t == __y._M_t; }
+# 783 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/bits/stl_multimap.h" 3
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __x._M_t < __y._M_t; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x == __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+              const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return __y < __x; }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__y < __x); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline bool
+    operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+               const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { return !(__x < __y); }
+
+
+  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
+    inline void
+    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
+         multimap<_Key, _Tp, _Compare, _Alloc>& __y)
+    { __x.swap(__y); }
+
+}
+# 63 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/map" 2 3
+# 17 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 1 3
+# 37 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 3
+       
+# 38 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default"))) {
+# 59 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/iostream" 3
+  extern istream cin;
+  extern ostream cout;
+  extern ostream cerr;
+  extern ostream clog;
+
+
+  extern wistream wcin;
+  extern wostream wcout;
+  extern wostream wcerr;
+  extern wostream wclog;
+
+
+
+
+  static ios_base::Init __ioinit;
+
+}
+# 18 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp" 2
+
+namespace boost { namespace python { namespace detail {
+
+
+
+
+
+
+
+    template <class Proxy>
+    struct compare_proxy_index
+    {
+
+
+
+
+        template <class Index>
+        bool operator()(PyObject* prox, Index i) const
+        {
+            typedef typename Proxy::policies_type policies_type;
+            Proxy& proxy = extract<Proxy&>(prox)();
+            return policies_type::
+                compare_index(proxy.get_container(), proxy.get_index(), i);
+        }
+    };
+# 53 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
+    template <class Proxy>
+    class proxy_group
+    {
+    public:
+
+        typedef typename std::vector<PyObject*>::const_iterator const_iterator;
+        typedef typename std::vector<PyObject*>::iterator iterator;
+        typedef typename Proxy::index_type index_type;
+        typedef typename Proxy::policies_type policies_type;
+
+        iterator
+        first_proxy(index_type i)
+        {
+
+            return boost::detail::lower_bound(
+                proxies.begin(), proxies.end(),
+                i, compare_proxy_index<Proxy>());
+        }
+
+        void
+        remove(Proxy& proxy)
+        {
+
+            for (iterator iter = first_proxy(proxy.get_index());
+                iter != proxies.end(); ++iter)
+            {
+                if (&extract<Proxy&>(*iter)() == &proxy)
+                {
+                    proxies.erase(iter);
+                    break;
+                }
+            }
+            ;
+        }
+
+        void
+        add(PyObject* prox)
+        {
+            ;
+
+            proxies.insert(
+                first_proxy(extract<Proxy&>(prox)().get_index()), prox);
+            ;
+        }
+
+        void
+        erase(index_type i, mpl::false_)
+        {
+            ;
+
+            replace(i, i+1, 0);
+            ;
+        }
+
+        void
+        erase(index_type i, mpl::true_)
+        {
+            ;
+
+
+            iterator iter = first_proxy(i);
+            extract<Proxy&> p(*iter);
+
+            if (iter != proxies.end() && p().get_index() == i)
+            {
+                extract<Proxy&> p(*iter);
+                p().detach();
+                proxies.erase(iter);
+            }
+            ;
+        }
+
+        void
+        erase(index_type from, index_type to)
+        {
+
+
+            ;
+
+            replace(from, to, 0);
+            ;
+        }
+
+        void
+        replace(
+            index_type from,
+            index_type to,
+            typename std::vector<PyObject*>::size_type len)
+        {
+
+
+            ;
+
+
+
+
+
+
+
+            iterator left = first_proxy(from);
+            iterator right = proxies.end();
+
+            for (iterator iter = left; iter != right; ++iter)
+            {
+                if (extract<Proxy&>(*iter)().get_index() > to)
+                {
+                    right = iter;
+                    break;
+                }
+                extract<Proxy&> p(*iter);
+                p().detach();
+            }
+
+            typename std::vector<PyObject*>::size_type
+                offset = left-proxies.begin();
+            proxies.erase(left, right);
+            right = proxies.begin()+offset;
+
+            while (right != proxies.end())
+            {
+                typedef typename Proxy::container_type::difference_type difference_type;
+                extract<Proxy&> p(*right);
+                p().set_index(
+                    extract<Proxy&>(*right)().get_index()
+                    - (difference_type(to) - from - len)
+                );
+
+                ++right;
+            }
+            ;
+        }
+
+        PyObject*
+        find(index_type i)
+        {
+            ;
+
+
+
+            iterator iter = first_proxy(i);
+            if (iter != proxies.end()
+                && extract<Proxy&>(*iter)().get_index() == i)
+            {
+                ;
+                return *iter;
+            }
+            ;
+            return 0;
+        }
+
+        typename std::vector<PyObject*>::size_type
+        size() const
+        {
+            ;
+
+            return proxies.size();
+        }
+
+    private:
+# 240 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
+        std::vector<PyObject*> proxies;
+    };
+
+
+
+
+
+
+    template <class Proxy, class Container>
+    class proxy_links
+    {
+    public:
+
+        typedef std::map<Container*, proxy_group<Proxy> > links_t;
+        typedef typename Proxy::index_type index_type;
+
+        void
+        remove(Proxy& proxy)
+        {
+
+            typename links_t::iterator r = links.find(&proxy.get_container());
+            if (r != links.end())
+            {
+                r->second.remove(proxy);
+                if (r->second.size() == 0)
+                    links.erase(r);
+            }
+        }
+
+        void
+        add(PyObject* prox, Container& container)
+        {
+
+            links[&container].add(prox);
+        }
+
+        template <class NoSlice>
+        void erase(Container& container, index_type i, NoSlice no_slice)
+        {
+
+            typename links_t::iterator r = links.find(&container);
+            if (r != links.end())
+            {
+                r->second.erase(i, no_slice);
+                if (r->second.size() == 0)
+                    links.erase(r);
+            }
+        }
+
+        void
+        erase(Container& container, index_type from, index_type to)
+        {
+
+            typename links_t::iterator r = links.find(&container);
+            if (r != links.end())
+            {
+                r->second.erase(from, to);
+                if (r->second.size() == 0)
+                    links.erase(r);
+            }
+        }
+
+        void
+        replace(
+            Container& container,
+            index_type from, index_type to, index_type len)
+        {
+
+
+
+
+
+
+
+            typename links_t::iterator r = links.find(&container);
+            if (r != links.end())
+            {
+                r->second.replace(from, to, len);
+                if (r->second.size() == 0)
+                    links.erase(r);
+            }
+        }
+
+        PyObject*
+        find(Container& container, index_type i)
+        {
+
+
+
+            typename links_t::iterator r = links.find(&container);
+            if (r != links.end())
+                return r->second.find(i);
+            return 0;
+        }
+
+    private:
+
+        links_t links;
+    };
+# 351 "/usr/include/boost-1_42/boost/python/suite/indexing/detail/indexing_suite_detail.hpp"
+    template <class Container, class Index, class Policies>
+    class container_element
+    {
+    public:
+
+        typedef Index index_type;
+        typedef Container container_type;
+        typedef typename Policies::data_type element_type;
+        typedef Policies policies_type;
+        typedef container_element<Container, Index, Policies> self_t;
+        typedef proxy_group<self_t> links_type;
+
+        container_element(object container, Index index)
+            : ptr()
+            , container(container)
+            , index(index)
+        {
+        }
+
+        container_element(container_element const& ce)
+          : ptr(ce.ptr.get() == 0 ? 0 : new element_type(*ce.ptr.get()))
+          , container(ce.container)
+          , index(ce.index)
+        {
+        }
+
+        ~container_element()
+        {
+            if (!is_detached())
+                get_links().remove(*this);
+        }
+
+        element_type& operator*() const
+        {
+            if (is_detached())
+                return *get_pointer(ptr);
+            return Policies::get_item(get_container(), index);
+        }
+
+        element_type* get() const
+        {
+            if (is_detached())
+                return get_pointer(ptr);
+            return &Policies::get_item(get_container(), index);
+        }
+
+        void
+        detach()
+        {
+            if (!is_detached())
+            {
+                ptr.reset(
+                    new element_type(
+                        Policies::get_item(get_container(), index)));
+                container = object();
+            }
+        }
+
+        bool
+        is_detached() const
+        {
+            return get_pointer(ptr) != 0;
+        }
+
+        Container&
+        get_container() const
+        {
+            return extract<Container&>(container)();
+        }
+
+        Index
+        get_index() const
+        {
+            return index;
+        }
+
+        void
+        set_index(Index i)
+        {
+            index = i;
+        }
+
+        static proxy_links<self_t, Container>&
+        get_links()
+        {
+
+
+
+
+            static proxy_links<self_t, Container> links;
+            return links;
+        }
+
+    private:
+
+        container_element& operator=(container_element const& ce);
+
+        scoped_ptr<element_type> ptr;
+        object container;
+        Index index;
+    };
+
+    template <
+          class Container
+        , class DerivedPolicies
+        , class ContainerElement
+        , class Index
+    >
+    struct no_proxy_helper
+    {
+        static void
+        register_container_element()
+        {
+        }
+
+        template <class DataType>
+        static object
+        base_get_item_helper(DataType const& p, mpl::true_)
+        {
+            return object(ptr(p));
+        }
+
+        template <class DataType>
+        static object
+        base_get_item_helper(DataType const& x, mpl::false_)
+        {
+            return object(x);
+        }
+
+        static object
+        base_get_item_(back_reference<Container&> const& container, PyObject* i)
+        {
+            return base_get_item_helper(
+                DerivedPolicies::get_item(
+                    container.get(), DerivedPolicies::
+                        convert_index(container.get(), i))
+              , is_pointer<typename Container::value_type>()
+            );
+        }
+
+        static void
+        base_replace_indexes(
+            Container& , Index ,
+            Index , Index )
+        {
+        }
+
+        template <class NoSlice>
+        static void
+        base_erase_index(
+            Container& , Index , NoSlice )
+        {
+        }
+
+        static void
+        base_erase_indexes(Container& , Index , Index )
+        {
+        }
+    };
+
+    template <
+          class Container
+        , class DerivedPolicies
+        , class ContainerElement
+        , class Index
+    >
+    struct proxy_helper
+    {
+        static void
+        register_container_element()
+        {
+            register_ptr_to_python<ContainerElement>();
+        }
+
+        static object
+        base_get_item_(back_reference<Container&> const& container, PyObject* i)
+        {
+
+            Index idx = DerivedPolicies::convert_index(container.get(), i);
+
+            if (PyObject* shared =
+                ContainerElement::get_links().find(container.get(), idx))
+            {
+                handle<> h(python::borrowed(shared));
+                return object(h);
+            }
+            else
+            {
+                object prox(ContainerElement(container.source(), idx));
+                ContainerElement::
+                    get_links().add(prox.ptr(), container.get());
+                return prox;
+            }
+        }
+
+        static void
+        base_replace_indexes(
+            Container& container, Index from,
+            Index to, Index n)
+        {
+            ContainerElement::get_links().replace(container, from, to, n);
+        }
+
+        template <class NoSlice>
+        static void
+        base_erase_index(
+            Container& container, Index i, NoSlice no_slice)
+        {
+            ContainerElement::get_links().erase(container, i, no_slice);
+        }
+
+        static void
+        base_erase_indexes(
+            Container& container, Index from, Index to)
+        {
+            ContainerElement::get_links().erase(container, from, to);
+        }
+    };
+
+    template <
+          class Container
+        , class DerivedPolicies
+        , class ProxyHandler
+        , class Data
+        , class Index
+    >
+    struct slice_helper
+    {
+        static object
+        base_get_slice(Container& container, PySliceObject* slice)
+        {
+            Index from, to;
+            base_get_slice_data(container, slice, from, to);
+            return DerivedPolicies::get_slice(container, from, to);
+        }
+
+        static void
+        base_get_slice_data(
+            Container& container, PySliceObject* slice, Index& from_, Index& to_)
+        {
+            if ((&_Py_NoneStruct) != slice->step) {
+                PyErr_SetString( PyExc_IndexError, "slice step size not supported.");
+                throw_error_already_set();
+            }
+
+            Index min_index = DerivedPolicies::get_min_index(container);
+            Index max_index = DerivedPolicies::get_max_index(container);
+
+            if ((&_Py_NoneStruct) == slice->start) {
+                from_ = min_index;
+            }
+            else {
+                long from = extract<long>( slice->start);
+                if (from < 0)
+                    from += max_index;
+                if (from < 0)
+                    from = 0;
+                from_ = boost::numeric_cast<Index>(from);
+                if (from_ > max_index)
+                    from_ = max_index;
+            }
+
+            if ((&_Py_NoneStruct) == slice->stop) {
+                to_ = max_index;
+            }
+            else {
+                long to = extract<long>( slice->stop);
+                if (to < 0)
+                    to += max_index;
+                if (to < 0)
+                    to = 0;
+                to_ = boost::numeric_cast<Index>(to);
+                if (to_ > max_index)
+                    to_ = max_index;
+            }
+        }
+
+        static void
+        base_set_slice(Container& container, PySliceObject* slice, PyObject* v)
+        {
+            Index from, to;
+            base_get_slice_data(container, slice, from, to);
+
+            extract<Data&> elem(v);
+
+            if (elem.check())
+            {
+                ProxyHandler::base_replace_indexes(container, from, to, 1);
+                DerivedPolicies::set_slice(container, from, to, elem());
+            }
+            else
+            {
+
+                extract<Data> elem(v);
+                if (elem.check())
+                {
+                    ProxyHandler::base_replace_indexes(container, from, to, 1);
+                    DerivedPolicies::set_slice(container, from, to, elem());
+                }
+                else
+                {
+
+                    handle<> l_(python::borrowed(v));
+                    object l(l_);
+
+                    std::vector<Data> temp;
+                    for (int i = 0; i < l.attr("__len__")(); i++)
+                    {
+                        object elem(l[i]);
+                        extract<Data const&> x(elem);
+
+                        if (x.check())
+                        {
+                            temp.push_back(x());
+                        }
+                        else
+                        {
+
+                            extract<Data> x(elem);
+                            if (x.check())
+                            {
+                                temp.push_back(x());
+                            }
+                            else
+                            {
+                                PyErr_SetString(PyExc_TypeError,
+                                    "Invalid sequence element");
+                                throw_error_already_set();
+                            }
+                        }
+                    }
+
+                    ProxyHandler::base_replace_indexes(container, from, to,
+                        temp.end()-temp.begin());
+                    DerivedPolicies::set_slice(container, from, to,
+                        temp.begin(), temp.end());
+                }
+            }
+        }
+
+        static void
+        base_delete_slice(Container& container, PySliceObject* slice)
+        {
+            Index from, to;
+            base_get_slice_data(container, slice, from, to);
+            ProxyHandler::base_erase_indexes(container, from, to);
+            DerivedPolicies::delete_slice(container, from, to);
+        }
+    };
+
+    template <
+          class Container
+        , class DerivedPolicies
+        , class ProxyHandler
+        , class Data
+        , class Index
+    >
+    struct no_slice_helper
+    {
+        static void
+        slicing_not_suported()
+        {
+            PyErr_SetString(PyExc_RuntimeError, "Slicing not supported");
+            throw_error_already_set();
+        }
+
+        static object
+        base_get_slice(Container& , PySliceObject* )
+        {
+            slicing_not_suported();
+            return object();
+        }
+
+        static void
+        base_set_slice(Container& , PySliceObject* , PyObject* )
+        {
+            slicing_not_suported();
+        }
+
+        static void
+        base_delete_slice(Container& , PySliceObject* )
+        {
+            slicing_not_suported();
+        }
+    };
+
+
+
+
+
+    template <class Container, class Index, class Policies>
+    inline typename Policies::data_type*
+    get_pointer(
+        python::detail::container_element<Container, Index, Policies> const& p)
+    {
+
+        return p.get();
+    }
+
+
+
+    using boost::python::get_pointer;
+    using boost::get_pointer;
+}}
+
+
+}
+# 13 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp" 2
+
+
+
+
+
+
+namespace boost { namespace python {
+# 98 "/usr/include/boost-1_42/boost/python/suite/indexing/indexing_suite.hpp"
+    template <
+          class Container
+        , class DerivedPolicies
+        , bool NoProxy = false
+        , bool NoSlice = false
+        , class Data = typename Container::value_type
+        , class Index = typename Container::size_type
+        , class Key = typename Container::value_type
+    >
+    class indexing_suite
+        : public def_visitor<
+            indexing_suite<
+              Container
+            , DerivedPolicies
+            , NoProxy
+            , NoSlice
+            , Data
+            , Index
+            , Key
+        > >
+    {
+    private:
+
+        typedef mpl::or_<
+            mpl::bool_<NoProxy>
+          , mpl::not_<is_class<Data> >
+          , typename mpl::or_<
+                is_same<Data, std::string>
+              , is_same<Data, std::complex<float> >
+              , is_same<Data, std::complex<double> >
+              , is_same<Data, std::complex<long double> > >::type>
+        no_proxy;
+
+        typedef detail::container_element<Container, Index, DerivedPolicies>
+            container_element_t;
+
+
+
+
+        typedef return_internal_reference<> return_policy;
+
+
+        typedef typename mpl::if_<
+            no_proxy
+          , iterator<Container>
+          , iterator<Container, return_policy> >::type
+        def_iterator;
+
+        typedef typename mpl::if_<
+            no_proxy
+          , detail::no_proxy_helper<
+                Container
+              , DerivedPolicies
+              , container_element_t
+              , Index>
+          , detail::proxy_helper<
+                Container
+              , DerivedPolicies
+              , container_element_t
+              , Index> >::type
+        proxy_handler;
+
+        typedef typename mpl::if_<
+            mpl::bool_<NoSlice>
+          , detail::no_slice_helper<
+                Container
+              , DerivedPolicies
+              , proxy_handler
+              , Data
+              , Index>
+          , detail::slice_helper<
+                Container
+              , DerivedPolicies
+              , proxy_handler
+              , Data
+              , Index> >::type
+        slice_handler;
+
+    public:
+
+        template <class Class>
+        void visit(Class& cl) const
+        {
+
+            proxy_handler::register_container_element();
+
+            cl
+                .def("__len__", base_size)
+                .def("__setitem__", &base_set_item)
+                .def("__delitem__", &base_delete_item)
+                .def("__getitem__", &base_get_item)
+                .def("__contains__", &base_contains)
+                .def("__iter__", def_iterator())
+            ;
+
+            DerivedPolicies::extension_def(cl);
+        }
+
+        template <class Class>
+        static void
+        extension_def(Class& cl)
+        {
+
+
+        }
+
+    private:
+
+        static object
+        base_get_item(back_reference<Container&> container, PyObject* i)
+        {
+            if (((((PyObject*)(i))->ob_type) == &PySlice_Type))
+                return slice_handler::base_get_slice(
+                    container.get(), static_cast<PySliceObject*>(static_cast<void*>(i)));
+
+            return proxy_handler::base_get_item_(container, i);
+        }
+
+        static void
+        base_set_item(Container& container, PyObject* i, PyObject* v)
+        {
+            if (((((PyObject*)(i))->ob_type) == &PySlice_Type))
+            {
+                 slice_handler::base_set_slice(container,
+                     static_cast<PySliceObject*>(static_cast<void*>(i)), v);
+            }
+            else
+            {
+                extract<Data&> elem(v);
+
+                if (elem.check())
+                {
+                    DerivedPolicies::
+                        set_item(container,
+                            DerivedPolicies::
+                                convert_index(container, i), elem());
+                }
+                else
+                {
+
+                    extract<Data> elem(v);
+                    if (elem.check())
+                    {
+                        DerivedPolicies::
+                            set_item(container,
+                                DerivedPolicies::
+                                    convert_index(container, i), elem());
+                    }
+                    else
+                    {
+                        PyErr_SetString(PyExc_TypeError, "Invalid assignment");
+                        throw_error_already_set();
+                    }
+                }
+            }
+        }
+
+        static void
+        base_delete_item(Container& container, PyObject* i)
+        {
+            if (((((PyObject*)(i))->ob_type) == &PySlice_Type))
+            {
+                slice_handler::base_delete_slice(
+                    container, static_cast<PySliceObject*>(static_cast<void*>(i)));
+                return;
+            }
+
+            Index index = DerivedPolicies::convert_index(container, i);
+            proxy_handler::base_erase_index(container, index, mpl::bool_<NoSlice>());
+            DerivedPolicies::delete_item(container, index);
+        }
+
+        static size_t
+        base_size(Container& container)
+        {
+            return DerivedPolicies::size(container);
+        }
+
+        static bool
+        base_contains(Container& container, PyObject* key)
+        {
+            extract<Key const&> x(key);
+
+            if (x.check())
+            {
+                return DerivedPolicies::contains(container, x());
+            }
+            else
+            {
+
+                extract<Key> x(key);
+                if (x.check())
+                    return DerivedPolicies::contains(container, x());
+                else
+                    return false;
+            }
+        }
+    };
+
+}}
+# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+# 1 "/usr/include/boost-1_42/boost/foreach.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/foreach.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 27 "/usr/include/boost-1_42/boost/foreach.hpp" 2
+# 68 "/usr/include/boost-1_42/boost/foreach.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/logical.hpp" 1
+# 69 "/usr/include/boost-1_42/boost/foreach.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/range/end.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/range/end.hpp"
+# 1 "/usr/include/boost-1_42/boost/range/config.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/range/end.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp"
+# 1 "/usr/include/boost-1_42/boost/range/detail/common.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/range/detail/common.hpp"
+# 1 "/usr/include/boost-1_42/boost/range/detail/sfinae.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/range/detail/sfinae.hpp"
+namespace boost
+{
+    namespace range_detail
+    {
+        using type_traits::yes_type;
+        using type_traits::no_type;
+
+
+
+
+
+        yes_type is_string_impl( const char* const );
+        yes_type is_string_impl( const wchar_t* const );
+        no_type is_string_impl( ... );
+
+        template< std::size_t sz >
+        yes_type is_char_array_impl( char (&boost_range_array)[sz] );
+        template< std::size_t sz >
+        yes_type is_char_array_impl( const char (&boost_range_array)[sz] );
+        no_type is_char_array_impl( ... );
+
+        template< std::size_t sz >
+        yes_type is_wchar_t_array_impl( wchar_t (&boost_range_array)[sz] );
+        template< std::size_t sz >
+        yes_type is_wchar_t_array_impl( const wchar_t (&boost_range_array)[sz] );
+        no_type is_wchar_t_array_impl( ... );
+
+        yes_type is_char_ptr_impl( char* const );
+        no_type is_char_ptr_impl( ... );
+
+        yes_type is_const_char_ptr_impl( const char* const );
+        no_type is_const_char_ptr_impl( ... );
+
+        yes_type is_wchar_t_ptr_impl( wchar_t* const );
+        no_type is_wchar_t_ptr_impl( ... );
+
+        yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
+        no_type is_const_wchar_t_ptr_impl( ... );
+
+
+
+
+
+        template< typename Iterator >
+        yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
+        no_type is_pair_impl( ... );
+
+
+
+
+
+        struct char_or_wchar_t_array_tag {};
+
+    }
+
+}
+# 20 "/usr/include/boost-1_42/boost/range/detail/common.hpp" 2
+
+
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 25 "/usr/include/boost-1_42/boost/range/detail/common.hpp" 2
+
+
+
+
+
+namespace boost
+{
+    namespace range_detail
+    {
+# 47 "/usr/include/boost-1_42/boost/range/detail/common.hpp"
+        typedef mpl::int_<1>::type std_container_;
+        typedef mpl::int_<2>::type std_pair_;
+        typedef mpl::int_<3>::type const_std_pair_;
+        typedef mpl::int_<4>::type array_;
+        typedef mpl::int_<5>::type const_array_;
+        typedef mpl::int_<6>::type char_array_;
+        typedef mpl::int_<7>::type wchar_t_array_;
+        typedef mpl::int_<8>::type char_ptr_;
+        typedef mpl::int_<9>::type const_char_ptr_;
+        typedef mpl::int_<10>::type wchar_t_ptr_;
+        typedef mpl::int_<11>::type const_wchar_t_ptr_;
+        typedef mpl::int_<12>::type string_;
+
+        template< typename C >
+        struct range_helper
+        {
+            static C* c;
+            static C ptr;
+
+            static const bool is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type );
+            static const bool is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type );
+            static const bool is_string_ = (boost::type_traits::ice_or<is_const_char_ptr_, is_const_wchar_t_ptr_>::value );
+            static const bool is_array_ = boost::is_array<C>::value;
+
+        };
+
+        template< typename C >
+        class range
+        {
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
+                                                                  boost::range_detail::std_pair_,
+                                                                  void >::type pair_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
+                                                                    boost::range_detail::array_,
+                                                                    pair_t >::type array_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
+                                                                    boost::range_detail::string_,
+                                                                    array_t >::type string_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
+                                                                    boost::range_detail::const_char_ptr_,
+                                                                    string_t >::type const_char_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
+                                                                    boost::range_detail::char_ptr_,
+                                                                    const_char_ptr_t >::type char_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
+                                                                    boost::range_detail::const_wchar_t_ptr_,
+                                                                    char_ptr_t >::type const_wchar_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
+                                                                    boost::range_detail::wchar_t_ptr_,
+                                                                    const_wchar_ptr_t >::type wchar_ptr_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
+                                                                    boost::range_detail::wchar_t_array_,
+                                                                    wchar_ptr_t >::type wchar_array_t;
+            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
+                                                                    boost::range_detail::char_array_,
+                                                                    wchar_array_t >::type char_array_t;
+        public:
+            typedef typename boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
+                                                                    boost::range_detail::std_container_,
+                                                                    char_array_t >::type type;
+        };
+    }
+}
+# 16 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 2
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 18 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 2
+
+
+
+# 1 "/usr/include/wchar.h" 1 3 4
+# 22 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp" 2
+
+
+namespace boost
+{
+    namespace range_detail
+    {
+        template <typename T>
+        inline void boost_range_silence_warning( const T& ) { }
+
+
+
+
+
+        inline const char* str_end( const char* s, const char* )
+        {
+            return s + strlen( s );
+        }
+
+
+        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
+        {
+            return s + wcslen( s );
+        }
+# 56 "/usr/include/boost-1_42/boost/range/detail/implementation_help.hpp"
+        template< class Char >
+        inline Char* str_end( Char* s )
+        {
+            return const_cast<Char*>( str_end( s, s ) );
+        }
+
+        template< class T, std::size_t sz >
+        inline T* array_end( T (&boost_range_array)[sz] )
+        {
+            return boost_range_array + sz;
+        }
+
+        template< class T, std::size_t sz >
+        inline const T* array_end( const T (&boost_range_array)[sz] )
+        {
+            return boost_range_array + sz;
+        }
+
+
+
+
+
+        template< class Char >
+        inline std::size_t str_size( const Char* const& s )
+        {
+            return str_end( s ) - s;
+        }
+
+        template< class T, std::size_t sz >
+        inline std::size_t array_size( T (&boost_range_array)[sz] )
+        {
+            boost_range_silence_warning( boost_range_array );
+            return sz;
+        }
+
+        template< class T, std::size_t sz >
+        inline std::size_t array_size( const T (&boost_range_array)[sz] )
+        {
+            boost_range_silence_warning( boost_range_array );
+            return sz;
+        }
+
+    }
+
+}
+# 25 "/usr/include/boost-1_42/boost/range/end.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/range/iterator.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/range/iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/range/mutable_iterator.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/range/mutable_iterator.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 26 "/usr/include/boost-1_42/boost/range/mutable_iterator.hpp" 2
+
+
+namespace boost
+{
+
+
+
+
+    template< typename C >
+    struct range_mutable_iterator
+    {
+        typedef typename C::iterator type;
+    };
+
+
+
+
+
+    template< typename Iterator >
+    struct range_mutable_iterator< std::pair<Iterator,Iterator> >
+    {
+        typedef Iterator type;
+    };
+
+
+
+
+
+    template< typename T, std::size_t sz >
+    struct range_mutable_iterator< T[sz] >
+    {
+        typedef T* type;
+    };
+
+}
+# 20 "/usr/include/boost-1_42/boost/range/iterator.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/range/const_iterator.hpp" 1
+# 25 "/usr/include/boost-1_42/boost/range/const_iterator.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 26 "/usr/include/boost-1_42/boost/range/const_iterator.hpp" 2
+
+
+namespace boost
+{
+
+
+
+
+    template< typename C >
+    struct range_const_iterator
+    {
+        typedef typename C::const_iterator type;
+    };
+
+
+
+
+
+    template< typename Iterator >
+    struct range_const_iterator< std::pair<Iterator,Iterator> >
+    {
+        typedef Iterator type;
+    };
+
+
+
+
+
+    template< typename T, std::size_t sz >
+    struct range_const_iterator< T[sz] >
+    {
+        typedef const T* type;
+    };
+
+}
+# 21 "/usr/include/boost-1_42/boost/range/iterator.hpp" 2
+
+
+
+
+namespace boost
+{
+# 50 "/usr/include/boost-1_42/boost/range/iterator.hpp"
+    template< typename C >
+    struct range_iterator
+    {
+
+
+
+
+
+
+
+        typedef typename
+            mpl::eval_if_c< is_const<C>::value,
+                            range_const_iterator< typename remove_const<C>::type >,
+                            range_mutable_iterator<C> >::type type;
+
+
+    };
+
+}
+# 26 "/usr/include/boost-1_42/boost/range/end.hpp" 2
+
+
+namespace boost
+{
+
+
+
+
+namespace range_detail
+{
+
+
+
+
+
+        template< typename C >
+        inline typename range_iterator<C>::type
+        range_end( C& c )
+        {
+
+
+
+
+
+            return c.end();
+        }
+
+
+
+
+
+        template< typename Iterator >
+        inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
+        {
+            return p.second;
+        }
+
+        template< typename Iterator >
+        inline Iterator range_end( std::pair<Iterator,Iterator>& p )
+        {
+            return p.second;
+        }
+
+
+
+
+
+        template< typename T, std::size_t sz >
+        inline const T* range_end( const T (&a)[sz] )
+        {
+            return range_detail::array_end<T,sz>( a );
+        }
+
+        template< typename T, std::size_t sz >
+        inline T* range_end( T (&a)[sz] )
+        {
+            return range_detail::array_end<T,sz>( a );
+        }
+
+
+
+
+}
+
+
+template< class T >
+inline typename range_iterator<T>::type end( T& r )
+{
+
+
+
+    using namespace range_detail;
+
+    return range_end( r );
+}
+
+template< class T >
+inline typename range_iterator<const T>::type end( const T& r )
+{
+
+
+
+    using namespace range_detail;
+
+    return range_end( r );
+}
+
+}
+
+
+
+
+
+
+namespace boost
+{
+    template< class T >
+    inline typename range_iterator<const T>::type
+    const_end( const T& r )
+    {
+        return boost::end( r );
+    }
+}
+# 72 "/usr/include/boost-1_42/boost/foreach.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/range/begin.hpp" 1
+# 26 "/usr/include/boost-1_42/boost/range/begin.hpp"
+namespace boost
+{
+
+
+
+
+namespace range_detail
+{
+
+
+
+
+
+
+    template< typename C >
+    inline typename range_iterator<C>::type
+    range_begin( C& c )
+    {
+
+
+
+
+
+        return c.begin();
+    }
+
+
+
+
+
+    template< typename Iterator >
+    inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
+    {
+        return p.first;
+    }
+
+    template< typename Iterator >
+    inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
+    {
+        return p.first;
+    }
+# 75 "/usr/include/boost-1_42/boost/range/begin.hpp"
+    template< typename T, std::size_t sz >
+    inline const T* range_begin( const T (&a)[sz] )
+    {
+        return a;
+    }
+
+    template< typename T, std::size_t sz >
+    inline T* range_begin( T (&a)[sz] )
+    {
+        return a;
+    }
+
+
+
+
+
+}
+
+
+
+template< class T >
+inline typename range_iterator<T>::type begin( T& r )
+{
+
+
+
+    using namespace range_detail;
+
+    return range_begin( r );
+}
+
+template< class T >
+inline typename range_iterator<const T>::type begin( const T& r )
+{
+
+
+
+    using namespace range_detail;
+
+    return range_begin( r );
+}
+
+}
+
+
+
+namespace boost
+{
+    template< class T >
+    inline typename range_iterator<const T>::type
+    const_begin( const T& r )
+    {
+        return boost::begin( r );
+    }
+}
+# 73 "/usr/include/boost-1_42/boost/foreach.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/range/rend.hpp" 1
+# 19 "/usr/include/boost-1_42/boost/range/rend.hpp"
+# 1 "/usr/include/boost-1_42/boost/range/reverse_iterator.hpp" 1
+# 20 "/usr/include/boost-1_42/boost/range/reverse_iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/reverse_iterator.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/iterator/reverse_iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 1
+# 14 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
+# 12 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 2
+
+
+
+
+
+# 1 "/usr/include/boost-1_42/boost/mpl/placeholders.hpp" 1
+# 18 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 2
+
+
+
+
+
+
+namespace boost {
+
+
+
+
+
+struct no_traversal_tag {};
+
+struct incrementable_traversal_tag
+  : no_traversal_tag
+{
+
+
+};
+
+struct single_pass_traversal_tag
+  : incrementable_traversal_tag
+{
+
+
+};
+
+struct forward_traversal_tag
+  : single_pass_traversal_tag
+{
+
+
+};
+
+struct bidirectional_traversal_tag
+  : forward_traversal_tag
+{
+
+
+};
+
+struct random_access_traversal_tag
+  : bidirectional_traversal_tag
+{
+
+
+};
+
+namespace detail
+{
+
+
+
+
+
+
+  template <class Cat>
+  struct old_category_to_traversal
+    : mpl::eval_if<
+          is_convertible<Cat,std::random_access_iterator_tag>
+        , mpl::identity<random_access_traversal_tag>
+        , mpl::eval_if<
+              is_convertible<Cat,std::bidirectional_iterator_tag>
+            , mpl::identity<bidirectional_traversal_tag>
+            , mpl::eval_if<
+                  is_convertible<Cat,std::forward_iterator_tag>
+                , mpl::identity<forward_traversal_tag>
+                , mpl::eval_if<
+                      is_convertible<Cat,std::input_iterator_tag>
+                    , mpl::identity<single_pass_traversal_tag>
+                    , mpl::eval_if<
+                          is_convertible<Cat,std::output_iterator_tag>
+                        , mpl::identity<incrementable_traversal_tag>
+                        , void
+                      >
+                  >
+              >
+          >
+      >
+  {};
+# 108 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
+  template <class Traversal>
+  struct pure_traversal_tag
+    : mpl::eval_if<
+          is_convertible<Traversal,random_access_traversal_tag>
+        , mpl::identity<random_access_traversal_tag>
+        , mpl::eval_if<
+              is_convertible<Traversal,bidirectional_traversal_tag>
+            , mpl::identity<bidirectional_traversal_tag>
+            , mpl::eval_if<
+                  is_convertible<Traversal,forward_traversal_tag>
+                , mpl::identity<forward_traversal_tag>
+                , mpl::eval_if<
+                      is_convertible<Traversal,single_pass_traversal_tag>
+                    , mpl::identity<single_pass_traversal_tag>
+                    , mpl::eval_if<
+                          is_convertible<Traversal,incrementable_traversal_tag>
+                        , mpl::identity<incrementable_traversal_tag>
+                        , void
+                      >
+                  >
+              >
+          >
+      >
+  {
+  };
+# 142 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
+}
+
+
+
+
+
+template <class Cat>
+struct iterator_category_to_traversal
+  : mpl::eval_if<
+        is_convertible<Cat,incrementable_traversal_tag>
+      , mpl::identity<Cat>
+      , boost::detail::old_category_to_traversal<Cat>
+    >
+{};
+
+
+template <class Iterator = mpl::_1>
+struct iterator_traversal
+  : iterator_category_to_traversal<
+        typename boost::detail::iterator_traits<Iterator>::iterator_category
+    >
+{};
+# 184 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp"
+}
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
+# 187 "/usr/include/boost-1_42/boost/iterator/iterator_categories.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp" 1
+# 15 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
+# 16 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp" 2
+
+namespace boost
+{
+# 34 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp"
+  template <typename A, typename B>
+  struct is_interoperable
+
+
+
+    : mpl::or_<
+          is_convertible< A, B >
+        , is_convertible< B, A > >
+
+  {
+  };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
+# 49 "/usr/include/boost-1_42/boost/iterator/interoperable.hpp" 2
+# 12 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp" 1
+# 23 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
+# 24 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp" 2
+# 34 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp"
+namespace boost { struct use_default; }
+
+namespace boost { namespace detail {
+
+struct input_output_iterator_tag
+  : std::input_iterator_tag
+{
+
+
+
+
+
+
+    operator std::output_iterator_tag() const
+    {
+        return std::output_iterator_tag();
+    }
+};
+
+
+
+
+
+
+template <class ValueParam, class Reference>
+struct iterator_writability_disabled
+
+  : mpl::or_<
+        is_const<Reference>
+      , boost::detail::indirect_traits::is_reference_to_const<Reference>
+      , is_const<ValueParam>
+    >
+
+
+
+{};
+# 86 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp"
+template <class Traversal, class ValueParam, class Reference>
+struct iterator_facade_default_category
+  : mpl::eval_if<
+        mpl::and_<
+            is_reference<Reference>
+          , is_convertible<Traversal,forward_traversal_tag>
+        >
+      , mpl::eval_if<
+            is_convertible<Traversal,random_access_traversal_tag>
+          , mpl::identity<std::random_access_iterator_tag>
+          , mpl::if_<
+                is_convertible<Traversal,bidirectional_traversal_tag>
+              , std::bidirectional_iterator_tag
+              , std::forward_iterator_tag
+            >
+        >
+      , typename mpl::eval_if<
+            mpl::and_<
+                is_convertible<Traversal, single_pass_traversal_tag>
+
+
+              , is_convertible<Reference, ValueParam>
+            >
+          , mpl::identity<std::input_iterator_tag>
+          , mpl::identity<Traversal>
+        >
+    >
+{
+};
+
+
+template <class T>
+struct is_iterator_category
+  : mpl::or_<
+        is_convertible<T,std::input_iterator_tag>
+      , is_convertible<T,std::output_iterator_tag>
+    >
+{
+};
+
+template <class T>
+struct is_iterator_traversal
+  : is_convertible<T,incrementable_traversal_tag>
+{};
+
+
+
+
+
+
+
+template <class Category, class Traversal>
+struct iterator_category_with_traversal
+  : Category, Traversal
+{
+
+
+
+
+    enum { mpl_assertion_in_line_149 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) ( is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >))0, 1 ) ) ) }
+
+
+
+             ;
+
+    enum { mpl_assertion_in_line_151 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_category<Category>))0, 1 ) ) ) };
+    enum { mpl_assertion_in_line_152 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
+    enum { mpl_assertion_in_line_153 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_traversal<Category>))0, 1 ) ) ) };
+
+    enum { mpl_assertion_in_line_155 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_iterator_traversal<Traversal>))0, 1 ) ) ) };
+
+
+};
+
+
+
+template <class Traversal, class ValueParam, class Reference>
+struct facade_iterator_category_impl
+{
+
+    enum { mpl_assertion_in_line_166 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (is_iterator_category<Traversal>))0, 1 ) ) ) };
+
+
+    typedef typename iterator_facade_default_category<
+        Traversal,ValueParam,Reference
+    >::type category;
+
+    typedef typename mpl::if_<
+        is_same<
+            Traversal
+          , typename iterator_category_to_traversal<category>::type
+        >
+      , category
+      , iterator_category_with_traversal<category,Traversal>
+    >::type type;
+};
+
+
+
+
+template <class CategoryOrTraversal, class ValueParam, class Reference>
+struct facade_iterator_category
+  : mpl::eval_if<
+        is_iterator_category<CategoryOrTraversal>
+      , mpl::identity<CategoryOrTraversal>
+      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
+    >
+{
+};
+
+}}
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
+# 199 "/usr/include/boost-1_42/boost/iterator/detail/facade_iterator_category.hpp" 2
+# 15 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
+# 33 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+# 1 "/usr/include/boost-1_42/boost/mpl/always.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/mpl/always.hpp"
+namespace boost { namespace mpl {
+
+template< typename Value > struct always
+{
+    template<
+          typename T
+        , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na
+        >
+    struct apply
+    {
+        typedef Value type;
+    };
+};
+
+
+
+}}
+# 34 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/mpl/apply.hpp" 1
+# 35 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
+
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
+# 38 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
+
+namespace boost
+{
+
+
+  template <class I, class V, class TC, class R, class D> class iterator_facade;
+
+  namespace detail
+  {
+
+
+
+    struct always_bool2
+    {
+        template <class T, class U>
+        struct apply
+        {
+            typedef bool type;
+        };
+    };
+
+
+
+
+    template <
+        class Facade1
+      , class Facade2
+      , class Return
+    >
+    struct enable_if_interoperable
+# 80 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+      : ::boost::iterators::enable_if<
+           mpl::or_<
+               is_convertible<Facade1, Facade2>
+             , is_convertible<Facade2, Facade1>
+           >
+         , Return
+        >
+    {};
+
+
+
+
+
+
+    template <
+        class ValueParam
+      , class CategoryOrTraversal
+      , class Reference
+      , class Difference
+    >
+    struct iterator_facade_types
+    {
+        typedef typename facade_iterator_category<
+            CategoryOrTraversal, ValueParam, Reference
+        >::type iterator_category;
+
+        typedef typename remove_const<ValueParam>::type value_type;
+
+        typedef typename mpl::eval_if<
+            boost::detail::iterator_writability_disabled<ValueParam,Reference>
+          , add_pointer<const value_type>
+          , add_pointer<value_type>
+        >::type pointer;
+# 130 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+    };
+
+
+
+
+
+
+
+    template <class Iterator>
+    class postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+        {}
+
+
+
+
+
+        value_type&
+        operator*() const
+        {
+            return this->stored_value;
+        }
+     private:
+        mutable value_type stored_value;
+    };
+
+
+
+
+
+    template <class Iterator>
+    class writable_postfix_increment_proxy
+    {
+        typedef typename iterator_value<Iterator>::type value_type;
+     public:
+        explicit writable_postfix_increment_proxy(Iterator const& x)
+          : stored_value(*x)
+          , stored_iterator(x)
+        {}
+
+
+
+
+
+        writable_postfix_increment_proxy const&
+        operator*() const
+        {
+            return *this;
+        }
+
+
+        operator value_type&() const
+        {
+            return stored_value;
+        }
+
+
+        template <class T>
+        T const& operator=(T const& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+
+
+        template <class T>
+        T& operator=(T& x) const
+        {
+            *this->stored_iterator = x;
+            return x;
+        }
+
+
+        operator Iterator const&() const
+        {
+            return stored_iterator;
+        }
+
+     private:
+        mutable value_type stored_value;
+        Iterator stored_iterator;
+    };
+# 244 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+    template <class Reference, class Value>
+    struct is_non_proxy_reference
+      : is_convertible<
+            typename remove_reference<Reference>::type
+            const volatile*
+          , Value const volatile*
+        >
+    {};
+# 269 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
+    struct postfix_increment_result
+      : mpl::eval_if<
+            mpl::and_<
+
+                is_convertible<Reference,Value const&>
+
+
+
+              , mpl::not_<
+                    is_convertible<
+                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
+                      , forward_traversal_tag
+                    >
+                >
+            >
+          , mpl::if_<
+                is_non_proxy_reference<Reference,Value>
+              , postfix_increment_proxy<Iterator>
+              , writable_postfix_increment_proxy<Iterator>
+            >
+          , mpl::identity<Iterator>
+        >
+    {};
+
+
+
+
+
+    template <class T>
+    struct operator_arrow_proxy
+    {
+        operator_arrow_proxy(T const* px) : m_value(*px) {}
+        T* operator->() const { return &m_value; }
+
+
+        operator T*() const { return &m_value; }
+        mutable T m_value;
+    };
+
+
+
+
+    template <class ValueType, class Reference, class Pointer>
+    struct operator_arrow_result
+    {
+
+
+
+        typedef typename mpl::if_<
+            is_reference<Reference>
+          , Pointer
+          , operator_arrow_proxy<ValueType>
+        >::type type;
+
+        static type make(Reference x)
+        {
+            return implicit_cast<type>(&x);
+        }
+    };
+# 342 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+    template <class Iterator>
+    class operator_brackets_proxy
+    {
+
+
+        typedef typename Iterator::reference reference;
+        typedef typename Iterator::value_type value_type;
+
+     public:
+        operator_brackets_proxy(Iterator const& iter)
+          : m_iter(iter)
+        {}
+
+        operator reference() const
+        {
+            return *m_iter;
+        }
+
+        operator_brackets_proxy& operator=(value_type const& val)
+        {
+            *m_iter = val;
+            return *this;
+        }
+
+     private:
+        Iterator m_iter;
+    };
+
+
+
+    template <class ValueType, class Reference>
+    struct use_operator_brackets_proxy
+      : mpl::not_<
+            mpl::and_<
+
+
+                boost::is_POD<ValueType>
+              , iterator_writability_disabled<ValueType,Reference>
+            >
+        >
+    {};
+
+    template <class Iterator, class Value, class Reference>
+    struct operator_brackets_result
+    {
+        typedef typename mpl::if_<
+            use_operator_brackets_proxy<Value,Reference>
+          , operator_brackets_proxy<Iterator>
+          , Value
+        >::type type;
+    };
+
+    template <class Iterator>
+    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
+    {
+        return operator_brackets_proxy<Iterator>(iter);
+    }
+
+    template <class Iterator>
+    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
+    {
+      return *iter;
+    }
+
+    struct choose_difference_type
+    {
+        template <class I1, class I2>
+        struct apply
+          :
+# 420 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+          mpl::eval_if<
+              is_convertible<I2,I1>
+            , iterator_difference<I1>
+            , iterator_difference<I2>
+          >
+
+        {};
+
+    };
+  }
+# 471 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+  class iterator_core_access
+  {
+
+
+
+
+
+
+      template <class I, class V, class TC, class R, class D> friend class iterator_facade;
+
+
+
+
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
+
+
+      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)
+
+      ;
+
+      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)
+
+
+
+
+      ;
+
+      template <class Derived, class V, class TC, class R, class D> friend inline Derived operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)
+
+
+
+
+      ;
+
+
+
+      template <class Facade>
+      static typename Facade::reference dereference(Facade const& f)
+      {
+          return f.dereference();
+      }
+
+      template <class Facade>
+      static void increment(Facade& f)
+      {
+          f.increment();
+      }
+
+      template <class Facade>
+      static void decrement(Facade& f)
+      {
+          f.decrement();
+      }
+
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return f1.equal(f2);
+      }
+
+      template <class Facade1, class Facade2>
+      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.equal(f1);
+      }
+
+      template <class Facade>
+      static void advance(Facade& f, typename Facade::difference_type n)
+      {
+          f.advance(n);
+      }
+
+      template <class Facade1, class Facade2>
+      static typename Facade1::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::true_)
+      {
+          return -f1.distance_to(f2);
+      }
+
+      template <class Facade1, class Facade2>
+      static typename Facade2::difference_type distance_from(
+          Facade1 const& f1, Facade2 const& f2, mpl::false_)
+      {
+          return f2.distance_to(f1);
+      }
+
+
+
+
+      template <class I, class V, class TC, class R, class D>
+      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
+      {
+          return *static_cast<I*>(&facade);
+      }
+
+      template <class I, class V, class TC, class R, class D>
+      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
+      {
+          return *static_cast<I const*>(&facade);
+      }
+
+   private:
+
+      iterator_core_access();
+  };
+
+
+
+
+
+  template <
+      class Derived
+    , class Value
+    , class CategoryOrTraversal
+    , class Reference = Value&
+    , class Difference = std::ptrdiff_t
+  >
+  class iterator_facade
+
+
+
+
+
+
+  {
+   private:
+
+
+
+      Derived& derived()
+      {
+          return *static_cast<Derived*>(this);
+      }
+
+      Derived const& derived() const
+      {
+          return *static_cast<Derived const*>(this);
+      }
+
+      typedef boost::detail::iterator_facade_types<
+         Value, CategoryOrTraversal, Reference, Difference
+      > associated_types;
+
+   protected:
+
+      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
+
+   public:
+
+      typedef typename associated_types::value_type value_type;
+      typedef Reference reference;
+      typedef Difference difference_type;
+      typedef typename associated_types::pointer pointer;
+      typedef typename associated_types::iterator_category iterator_category;
+
+      reference operator*() const
+      {
+          return iterator_core_access::dereference(this->derived());
+      }
+
+      typename boost::detail::operator_arrow_result<
+          value_type
+        , reference
+        , pointer
+      >::type
+      operator->() const
+      {
+          return boost::detail::operator_arrow_result<
+              value_type
+            , reference
+            , pointer
+          >::make(*this->derived());
+      }
+
+      typename boost::detail::operator_brackets_result<Derived,Value,reference>::type
+      operator[](difference_type n) const
+      {
+          typedef boost::detail::use_operator_brackets_proxy<Value,Reference> use_proxy;
+
+          return boost::detail::make_operator_brackets_result<Derived>(
+              this->derived() + n
+            , use_proxy()
+          );
+      }
+
+      Derived& operator++()
+      {
+          iterator_core_access::increment(this->derived());
+          return this->derived();
+      }
+# 679 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+      Derived& operator--()
+      {
+          iterator_core_access::decrement(this->derived());
+          return this->derived();
+      }
+
+      Derived operator--(int)
+      {
+          Derived tmp(this->derived());
+          --*this;
+          return tmp;
+      }
+
+      Derived& operator+=(difference_type n)
+      {
+          iterator_core_access::advance(this->derived(), n);
+          return this->derived();
+      }
+
+      Derived& operator-=(difference_type n)
+      {
+          iterator_core_access::advance(this->derived(), -n);
+          return this->derived();
+      }
+
+      Derived operator-(difference_type x) const
+      {
+          Derived result(this->derived());
+          return result -= x;
+      }
+# 721 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+  };
+
+
+  template <class I, class V, class TC, class R, class D>
+  inline typename boost::detail::postfix_increment_result<I,V,R,TC>::type
+  operator++(
+      iterator_facade<I,V,TC,R,D>& i
+    , int
+  )
+  {
+      typename boost::detail::postfix_increment_result<I,V,R,TC>::type
+          tmp(*static_cast<I*>(&i));
+
+      ++i;
+
+      return tmp;
+  }
+# 836 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_836; return iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_837; return ! iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_839; return 0 > iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_840; return 0 < iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_841; return 0 >= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)> boost_static_assert_typedef_842; return 0 <= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+
+
+
+  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((( is_interoperable< Derived1, Derived2 >::value )) == 0 ? false : true) >)>
+
+
+
+
+ boost_static_assert_typedef_851
+# 846 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+  ; return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
+# 862 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp"
+template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
+
+
+
+
+template <class Derived, class V, class TC, class R, class D> inline Derived operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
+
+
+
+
+
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
+# 877 "/usr/include/boost-1_42/boost/iterator/iterator_facade.hpp" 2
+# 16 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2
+# 36 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_def.hpp" 1
+# 37 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2
+
+
+
+namespace boost
+{
+
+
+
+  struct use_default;
+
+
+
+
+
+  template<class To>
+  struct is_convertible<use_default,To>
+    : mpl::false_ {};
+
+
+  namespace detail
+  {
+# 66 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
+    struct enable_type;
+  }
+# 148 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
+  template<typename From, typename To>
+  struct enable_if_convertible
+    : iterators::enable_if<
+          is_convertible<From, To>
+        , boost::detail::enable_type
+      >
+  {};
+
+
+
+
+
+
+  namespace detail
+  {
+
+
+    template <class T, class DefaultNullaryFn>
+    struct ia_dflt_help
+      : mpl::eval_if<
+            is_same<T, use_default>
+          , DefaultNullaryFn
+          , mpl::identity<T>
+        >
+    {
+    };
+
+
+
+    template <
+        class Derived
+      , class Base
+      , class Value
+      , class Traversal
+      , class Reference
+      , class Difference
+    >
+    struct iterator_adaptor_base
+    {
+        typedef iterator_facade<
+            Derived
+
+
+          , typename boost::detail::ia_dflt_help<
+                Value
+              , mpl::eval_if<
+                    is_same<Reference,use_default>
+                  , iterator_value<Base>
+                  , remove_reference<Reference>
+                >
+            >::type
+
+
+
+
+
+
+          , typename boost::detail::ia_dflt_help<
+                Traversal
+              , iterator_traversal<Base>
+            >::type
+
+          , typename boost::detail::ia_dflt_help<
+                Reference
+              , mpl::eval_if<
+                    is_same<Value,use_default>
+                  , iterator_reference<Base>
+                  , add_reference<Value>
+                >
+            >::type
+
+          , typename boost::detail::ia_dflt_help<
+                Difference, iterator_difference<Base>
+            >::type
+        >
+        type;
+    };
+
+
+    template <class Tr1, class Tr2>
+    inline void iterator_adaptor_assert_traversal ()
+    {
+      typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< (((is_convertible<Tr1, Tr2>::value)) == 0 ? false : true) >)> boost_static_assert_typedef_230;
+    }
+  }
+# 259 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp"
+  template <
+      class Derived
+    , class Base
+    , class Value = use_default
+    , class Traversal = use_default
+    , class Reference = use_default
+    , class Difference = use_default
+  >
+  class iterator_adaptor
+    : public boost::detail::iterator_adaptor_base<
+        Derived, Base, Value, Traversal, Reference, Difference
+      >::type
+  {
+      friend class iterator_core_access;
+
+   protected:
+      typedef typename boost::detail::iterator_adaptor_base<
+          Derived, Base, Value, Traversal, Reference, Difference
+      >::type super_t;
+   public:
+      iterator_adaptor() {}
+
+      explicit iterator_adaptor(Base const &iter)
+          : m_iterator(iter)
+      {
+      }
+
+      typedef Base base_type;
+
+      Base const& base() const
+        { return m_iterator; }
+
+   protected:
+
+      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;
+
+
+
+
+      Base const& base_reference() const
+        { return m_iterator; }
+
+      Base& base_reference()
+        { return m_iterator; }
+
+   private:
+
+
+
+
+
+
+      typename super_t::reference dereference() const
+        { return *m_iterator; }
+
+      template <
+      class OtherDerived, class OtherIterator, class V, class C, class R, class D
+      >
+      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
+      {
+
+
+
+
+          return m_iterator == x.base();
+      }
+
+      typedef typename iterator_category_to_traversal<
+          typename super_t::iterator_category
+      >::type my_traversal;
+
+
+
+
+      void advance(typename super_t::difference_type n)
+      {
+          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
+          m_iterator += n;
+      }
+
+      void increment() { ++m_iterator; }
+
+      void decrement()
+      {
+          boost::detail::iterator_adaptor_assert_traversal<my_traversal, bidirectional_traversal_tag>();
+           --m_iterator;
+      }
+
+      template <
+          class OtherDerived, class OtherIterator, class V, class C, class R, class D
+      >
+      typename super_t::difference_type distance_to(
+          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
+      {
+          boost::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
+
+
+
+
+          return y.base() - m_iterator;
+      }
+
+
+
+   private:
+      Base m_iterator;
+  };
+
+}
+
+# 1 "/usr/include/boost-1_42/boost/iterator/detail/config_undef.hpp" 1
+# 370 "/usr/include/boost-1_42/boost/iterator/iterator_adaptor.hpp" 2
+# 13 "/usr/include/boost-1_42/boost/iterator/reverse_iterator.hpp" 2
+
+namespace boost
+{
+
+
+
+
+  template <class Iterator>
+  class reverse_iterator
+      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
+  {
+      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;
+
+      friend class iterator_core_access;
+
+   public:
+      reverse_iterator() {}
+
+      explicit reverse_iterator(Iterator x)
+          : super_t(x) {}
+
+      template<class OtherIterator>
+      reverse_iterator(
+          reverse_iterator<OtherIterator> const& r
+          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
+          )
+          : super_t(r.base())
+      {}
+
+   private:
+      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
+
+      void increment() { --this->base_reference(); }
+      void decrement() { ++this->base_reference(); }
+
+      void advance(typename super_t::difference_type n)
+      {
+          this->base_reference() += -n;
+      }
+
+      template <class OtherIterator>
+      typename super_t::difference_type
+      distance_to(reverse_iterator<OtherIterator> const& y) const
+      {
+          return this->base_reference() - y.base();
+      }
+  };
+
+  template <class BidirectionalIterator>
+  reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
+  {
+      return reverse_iterator<BidirectionalIterator>(x);
+  }
+
+}
+# 21 "/usr/include/boost-1_42/boost/range/reverse_iterator.hpp" 2
+
+
+namespace boost
+{
+
+
+
+
+    template< typename C >
+    struct range_reverse_iterator
+    {
+        typedef reverse_iterator<
+            typename range_iterator<C>::type > type;
+    };
+
+
+}
+# 20 "/usr/include/boost-1_42/boost/range/rend.hpp" 2
+
+namespace boost
+{
+# 35 "/usr/include/boost-1_42/boost/range/rend.hpp"
+template< class C >
+inline typename range_reverse_iterator<C>::type
+rend( C& c )
+{
+    typedef typename range_reverse_iterator<C>::type
+               iter_type;
+    return iter_type( boost::begin( c ) );
+}
+
+template< class C >
+inline typename range_reverse_iterator<const C>::type
+rend( const C& c )
+{
+    typedef typename range_reverse_iterator<const C>::type
+        iter_type;
+    return iter_type( boost::begin( c ) );
+}
+
+
+
+template< class T >
+inline typename range_reverse_iterator<const T>::type
+const_rend( const T& r )
+{
+    return boost::rend( r );
+}
+
+}
+# 74 "/usr/include/boost-1_42/boost/foreach.hpp" 2
+# 1 "/usr/include/boost-1_42/boost/range/rbegin.hpp" 1
+# 21 "/usr/include/boost-1_42/boost/range/rbegin.hpp"
+namespace boost
+{
+# 35 "/usr/include/boost-1_42/boost/range/rbegin.hpp"
+template< class C >
+inline typename range_reverse_iterator<C>::type
+rbegin( C& c )
+{
+    typedef typename range_reverse_iterator<C>::type
+        iter_type;
+    return iter_type( boost::end( c ) );
+}
+
+template< class C >
+inline typename range_reverse_iterator<const C>::type
+rbegin( const C& c )
+{
+    typedef typename range_reverse_iterator<const C>::type
+        iter_type;
+    return iter_type( boost::end( c ) );
+}
+
+
+
+template< class T >
+inline typename range_reverse_iterator<const T>::type
+const_rbegin( const T& r )
+{
+    return boost::rbegin( r );
+}
+
+}
+# 75 "/usr/include/boost-1_42/boost/foreach.hpp" 2
+# 92 "/usr/include/boost-1_42/boost/foreach.hpp"
+enum boost_foreach_argument_dependent_lookup_hack
+{
+    boost_foreach_argument_dependent_lookup_hack_value
+};
+
+namespace boost
+{
+
+
+template<typename T>
+class iterator_range;
+
+
+template<typename T>
+class sub_range;
+
+namespace
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 109 "/usr/include/boost-1_42/boost/foreach.hpp"
+{
+
+
+
+    template<typename T>
+    inline std::pair<T, T> in_range(T begin, T end)
+    {
+        return std::make_pair(begin, end);
+    }
+
+
+
+
+    typedef boost_foreach_argument_dependent_lookup_hack tag;
+
+
+
+
+
+    template<typename T>
+    struct is_lightweight_proxy
+      : boost::mpl::false_
+    {
+    };
+
+
+
+
+
+    template<typename T>
+    struct is_noncopyable
+
+      : boost::mpl::or_<
+            boost::is_abstract<T>
+          , boost::is_base_and_derived<boost::noncopyable, T>
+        >
+
+
+
+
+
+
+
+    {
+    };
+
+}
+
+}
+# 171 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T>
+inline boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 172 "/usr/include/boost-1_42/boost/foreach.hpp"
+                     ::is_lightweight_proxy<T> *
+boost_foreach_is_lightweight_proxy(T *&, boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 173 "/usr/include/boost-1_42/boost/foreach.hpp"
+                                         ::tag) { return 0; }
+
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(std::pair<T, T> *&, boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 177 "/usr/include/boost-1_42/boost/foreach.hpp"
+                                                                     ::tag) { return 0; }
+
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(boost::iterator_range<T> *&, boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 181 "/usr/include/boost-1_42/boost/foreach.hpp"
+                                                                              ::tag) { return 0; }
+
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(boost::sub_range<T> *&, boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 185 "/usr/include/boost-1_42/boost/foreach.hpp"
+                                                                         ::tag) { return 0; }
+
+template<typename T>
+inline boost::mpl::true_ *
+boost_foreach_is_lightweight_proxy(T **&, boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 189 "/usr/include/boost-1_42/boost/foreach.hpp"
+                                                        ::tag) { return 0; }
+
+
+
+
+
+
+template<typename T>
+inline boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 197 "/usr/include/boost-1_42/boost/foreach.hpp"
+                     ::is_noncopyable<T> *
+boost_foreach_is_noncopyable(T *&, boost::
+# 2301 "/usr/include/qt4/QtCore/qglobal.h"
+                    Q_FOREACH
+# 198 "/usr/include/boost-1_42/boost/foreach.hpp"
+                                   ::tag) { return 0; }
+
+namespace boost
+{
+
+namespace foreach_detail_
+{
+
+
+
+
+template<typename Bool1, typename Bool2>
+inline boost::mpl::and_<Bool1, Bool2> *and_(Bool1 *, Bool2 *) { return 0; }
+
+template<typename Bool1, typename Bool2, typename Bool3>
+inline boost::mpl::and_<Bool1, Bool2, Bool3> *and_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
+
+template<typename Bool1, typename Bool2>
+inline boost::mpl::or_<Bool1, Bool2> *or_(Bool1 *, Bool2 *) { return 0; }
+
+template<typename Bool1, typename Bool2, typename Bool3>
+inline boost::mpl::or_<Bool1, Bool2, Bool3> *or_(Bool1 *, Bool2 *, Bool3 *) { return 0; }
+
+template<typename Bool1>
+inline boost::mpl::not_<Bool1> *not_(Bool1 *) { return 0; }
+
+template<typename T>
+inline boost::mpl::false_ *is_rvalue_(T &, int) { return 0; }
+
+template<typename T>
+inline boost::mpl::true_ *is_rvalue_(T const &, ...) { return 0; }
+
+template<typename T>
+inline boost::is_array<T> *is_array_(T const &) { return 0; }
+
+template<typename T>
+inline boost::is_const<T> *is_const_(T &) { return 0; }
+
+
+template<typename T>
+inline boost::mpl::true_ *is_const_(T const &) { return 0; }
+
+
+
+
+
+struct auto_any_base
+{
+
+
+    operator bool() const
+    {
+        return false;
+    }
+};
+
+template<typename T>
+struct auto_any : auto_any_base
+{
+    auto_any(T const &t)
+      : item(t)
+    {
+    }
+
+
+
+
+    mutable T item;
+};
+
+typedef auto_any_base const &auto_any_t;
+
+template<typename T, typename C>
+inline typename boost::mpl::if_<C, T const, T>::type &auto_any_cast(auto_any_t a)
+{
+    return static_cast<auto_any<T> const &>(a).item;
+}
+
+typedef boost::mpl::true_ const_;
+
+
+
+
+template<typename T, typename C = boost::mpl::false_>
+struct type2type
+  : boost::mpl::if_<C, T const, T>
+{
+};
+
+template<typename T>
+struct wrap_cstr
+{
+    typedef T type;
+};
+
+template<>
+struct wrap_cstr<char *>
+{
+    typedef wrap_cstr<char *> type;
+    typedef char *iterator;
+    typedef char *const_iterator;
+};
+
+template<>
+struct wrap_cstr<char const *>
+{
+    typedef wrap_cstr<char const *> type;
+    typedef char const *iterator;
+    typedef char const *const_iterator;
+};
+
+template<>
+struct wrap_cstr<wchar_t *>
+{
+    typedef wrap_cstr<wchar_t *> type;
+    typedef wchar_t *iterator;
+    typedef wchar_t *const_iterator;
+};
+
+template<>
+struct wrap_cstr<wchar_t const *>
+{
+    typedef wrap_cstr<wchar_t const *> type;
+    typedef wchar_t const *iterator;
+    typedef wchar_t const *const_iterator;
+};
+
+template<typename T>
+struct is_char_array
+  : mpl::and_<
+        is_array<T>
+      , mpl::or_<
+            is_convertible<T, char const *>
+          , is_convertible<T, wchar_t const *>
+        >
+    >
+{};
+
+template<typename T, typename C = boost::mpl::false_>
+struct foreach_iterator
+{
+# 352 "/usr/include/boost-1_42/boost/foreach.hpp"
+    struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING352 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg352; enum { mpl_assertion_in_line_352 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg352::assert_arg() ) ) };
+
+
+
+
+    typedef typename wrap_cstr<T>::type container;
+
+    typedef typename boost::mpl::eval_if<
+        C
+      , range_const_iterator<container>
+      , range_mutable_iterator<container>
+    >::type type;
+};
+
+
+template<typename T, typename C = boost::mpl::false_>
+struct foreach_reverse_iterator
+{
+# 383 "/usr/include/boost-1_42/boost/foreach.hpp"
+    struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING; typedef struct IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING383 : boost::mpl::assert_ { static boost::mpl::failed ************ (IS_THIS_AN_ARRAY_OR_A_NULL_TERMINATED_STRING::************ assert_arg()) (T&) { return 0; } } mpl_assert_arg383; enum { mpl_assertion_in_line_383 = sizeof( boost::mpl::assertion_failed<((!is_char_array<T>::value))>( mpl_assert_arg383::assert_arg() ) ) };
+
+
+
+
+    typedef typename wrap_cstr<T>::type container;
+
+    typedef typename boost::mpl::eval_if<
+        C
+      , range_reverse_iterator<container const>
+      , range_reverse_iterator<container>
+    >::type type;
+};
+
+template<typename T, typename C = boost::mpl::false_>
+struct foreach_reference
+  : iterator_reference<typename foreach_iterator<T, C>::type>
+{
+};
+
+
+
+
+template<typename T>
+inline type2type<T> *encode_type(T &, boost::mpl::false_ *) { return 0; }
+
+template<typename T>
+inline type2type<T, const_> *encode_type(T const &, boost::mpl::true_ *) { return 0; }
+
+
+
+
+inline bool set_false(bool &b)
+{
+    b = false;
+    return false;
+}
+
+
+
+
+template<typename T>
+inline T *&to_ptr(T const &)
+{
+    static T *t = 0;
+    return t;
+}
+# 444 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T>
+inline T &derefof(T *t)
+{
+
+
+    return reinterpret_cast<T &>(
+        *const_cast<char *>(
+            reinterpret_cast<char const volatile *>(t)
+        )
+    );
+}
+# 466 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T>
+struct rvalue_probe
+{
+    struct private_type_ {};
+
+    typedef typename boost::mpl::if_<
+        boost::mpl::or_<boost::is_abstract<T>, boost::is_array<T> >, private_type_, T
+    >::type value_type;
+    operator value_type() { return *reinterpret_cast<value_type *>(this); }
+    operator T &() const { return *reinterpret_cast<T *>(const_cast<rvalue_probe *>(this)); }
+};
+
+template<typename T>
+rvalue_probe<T> const make_probe(T const &)
+{
+    return rvalue_probe<T>();
+}
+# 614 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T>
+inline auto_any<T> contain(T const &t, boost::mpl::true_ *)
+{
+    return t;
+}
+
+template<typename T>
+inline auto_any<T *> contain(T &t, boost::mpl::false_ *)
+{
+
+
+
+
+    return boost::addressof(t);
+
+}
+# 643 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+begin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return boost::begin(auto_any_cast<T, C>(col));
+}
+
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+begin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_iterator<T, C>::type iterator;
+    return iterator(boost::begin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+}
+# 669 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T, typename C>
+inline auto_any<T *>
+begin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    return auto_any_cast<T *, boost::mpl::false_>(col);
+}
+
+
+
+
+
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+end(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return boost::end(auto_any_cast<T, C>(col));
+}
+
+template<typename T, typename C>
+inline auto_any<typename foreach_iterator<T, C>::type>
+end(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_iterator<T, C>::type iterator;
+    return iterator(boost::end(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+}
+# 706 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T, typename C>
+inline auto_any<int>
+end(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    return 0;
+}
+
+
+
+
+
+template<typename T, typename C>
+inline bool done(auto_any_t cur, auto_any_t end, type2type<T, C> *)
+{
+    typedef typename foreach_iterator<T, C>::type iter_t;
+    return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
+}
+
+
+template<typename T, typename C>
+inline bool done(auto_any_t cur, auto_any_t, type2type<T *, C> *)
+{
+    return ! *auto_any_cast<T *, boost::mpl::false_>(cur);
+}
+
+
+
+
+
+template<typename T, typename C>
+inline void next(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_iterator<T, C>::type iter_t;
+    ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+
+
+
+
+template<typename T, typename C>
+inline typename foreach_reference<T, C>::type
+deref(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_iterator<T, C>::type iter_t;
+    return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+
+
+
+
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return boost::rbegin(auto_any_cast<T, C>(col));
+}
+
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rbegin(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_reverse_iterator<T, C>::type iterator;
+    return iterator(boost::rbegin(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+}
+# 782 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T, typename C>
+inline auto_any<reverse_iterator<T *> >
+rbegin(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    T *p = auto_any_cast<T *, boost::mpl::false_>(col);
+    while(0 != *p)
+        ++p;
+    return reverse_iterator<T *>(p);
+}
+
+
+
+
+
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rend(auto_any_t col, type2type<T, C> *, boost::mpl::true_ *)
+{
+    return boost::rend(auto_any_cast<T, C>(col));
+}
+
+template<typename T, typename C>
+inline auto_any<typename foreach_reverse_iterator<T, C>::type>
+rend(auto_any_t col, type2type<T, C> *, boost::mpl::false_ *)
+{
+    typedef typename type2type<T, C>::type type;
+    typedef typename foreach_reverse_iterator<T, C>::type iterator;
+    return iterator(boost::rend(derefof(auto_any_cast<type *, boost::mpl::false_>(col))));
+}
+# 822 "/usr/include/boost-1_42/boost/foreach.hpp"
+template<typename T, typename C>
+inline auto_any<reverse_iterator<T *> >
+rend(auto_any_t col, type2type<T *, C> *, boost::mpl::true_ *)
+{
+    return reverse_iterator<T *>(auto_any_cast<T *, boost::mpl::false_>(col));
+}
+
+
+
+
+
+template<typename T, typename C>
+inline bool rdone(auto_any_t cur, auto_any_t end, type2type<T, C> *)
+{
+    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
+    return auto_any_cast<iter_t, boost::mpl::false_>(cur) == auto_any_cast<iter_t, boost::mpl::false_>(end);
+}
+
+
+
+
+template<typename T, typename C>
+inline void rnext(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
+    ++auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+
+
+
+
+template<typename T, typename C>
+inline typename foreach_reference<T, C>::type
+rderef(auto_any_t cur, type2type<T, C> *)
+{
+    typedef typename foreach_reverse_iterator<T, C>::type iter_t;
+    return *auto_any_cast<iter_t, boost::mpl::false_>(cur);
+}
+
+}
+}
+# 12 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp" 2
+
+
+
+# 1 "/usr/include/boost-1_42/boost/python/stl_iterator.hpp" 1
+# 10 "/usr/include/boost-1_42/boost/python/stl_iterator.hpp"
+# 1 "/usr/include/boost-1_42/boost/python/object/stl_iterator_core.hpp" 1
+# 11 "/usr/include/boost-1_42/boost/python/object/stl_iterator_core.hpp"
+namespace boost { namespace python { namespace objects {
+
+struct stl_input_iterator_impl
+{
+    stl_input_iterator_impl();
+    stl_input_iterator_impl(boost::python::object const &ob);
+    void increment();
+    bool equal(stl_input_iterator_impl const &that) const;
+    boost::python::handle<> const &current() const;
+private:
+    boost::python::object it_;
+    boost::python::handle<> ob_;
+};
+
+}}}
+# 11 "/usr/include/boost-1_42/boost/python/stl_iterator.hpp" 2
+
+
+
+namespace boost { namespace python
+{
+
+
+template<typename ValueT>
+struct stl_input_iterator
+  : boost::iterator_facade<
+        stl_input_iterator<ValueT>
+      , ValueT
+      , std::input_iterator_tag
+      , ValueT
+    >
+{
+    stl_input_iterator()
+      : impl_()
+    {
+    }
+
+
+    stl_input_iterator(boost::python::object const &ob)
+      : impl_(ob)
+    {
+    }
+
+private:
+    friend class boost::iterator_core_access;
+
+    void increment()
+    {
+        this->impl_.increment();
+    }
+
+    ValueT dereference() const
+    {
+        return extract<ValueT>(this->impl_.current().get())();
+    }
+
+    bool equal(stl_input_iterator<ValueT> const &that) const
+    {
+        return this->impl_.equal(that.impl_);
+    }
+
+    objects::stl_input_iterator_impl impl_;
+};
+
+}}
+# 16 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp" 2
+
+namespace boost { namespace python { namespace container_utils {
+
+    template <typename Container>
+    void
+    extend_container(Container& container, object l)
+    {
+        typedef typename Container::value_type data_type;
+
+
+        if (boost::foreach_detail_::auto_any_t
+
+
+
+ _foreach_col30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        = boost::foreach_detail_::contain( (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , (true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))) , (true ? 0 : boost::foreach_detail_::is_rvalue_( (true ? boost::foreach_detail_::make_probe(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) : (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))), 0))) , boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)))))) {} else if (boost::foreach_detail_::auto_any_t
+
+
+
+ _foreach_cur30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        = boost::foreach_detail_::begin(
+
+
+
+ _foreach_col30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )))) , (true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))) , (true ? 0 : boost::foreach_detail_::is_rvalue_( (true ? boost::foreach_detail_::make_probe(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) : (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))), 0))) , boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)))))) {} else if (boost::foreach_detail_::auto_any_t
+
+
+
+ _foreach_end30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        = boost::foreach_detail_::end(
+
+
+
+ _foreach_col30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )))) , (true ? 0 : boost::foreach_detail_::or_( boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost::foreach_detail_::is_array_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))) , (true ? 0 : boost::foreach_detail_::is_rvalue_( (true ? boost::foreach_detail_::make_probe(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) : (std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))), 0))) , boost::foreach_detail_::and_( boost::foreach_detail_::not_(boost_foreach_is_noncopyable( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)) , boost_foreach_is_lightweight_proxy( boost::foreach_detail_::to_ptr(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )) , boost_foreach_argument_dependent_lookup_hack_value)))))) {} else for (bool
+
+
+
+ _foreach_continue30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        = true;
+
+
+
+ _foreach_continue30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        && !boost::foreach_detail_::done(
+
+
+
+ _foreach_cur30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        ,
+
+
+
+ _foreach_end30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() )))));
+
+
+
+ _foreach_continue30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        ? boost::foreach_detail_::next(
+
+
+
+ _foreach_cur30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))))) : (void)0) if (boost::foreach_detail_::set_false(
+
+
+
+ _foreach_continue30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        )) {} else for (object elem = boost::foreach_detail_::deref(
+
+
+
+ _foreach_cur30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        , (true ? 0 : boost::foreach_detail_::encode_type(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ), boost::foreach_detail_::is_const_(std::make_pair( boost::python::stl_input_iterator<object>(l), boost::python::stl_input_iterator<object>() ))))); !
+
+
+
+ _foreach_continue30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        ;
+
+
+
+ _foreach_continue30
+# 26 "/usr/include/boost-1_42/boost/python/suite/indexing/container_utils.hpp"
+        = true)
+
+
+
+
+        {
+            extract<data_type const&> x(elem);
+
+            if (x.check())
+            {
+                container.push_back(x());
+            }
+            else
+            {
+
+                extract<data_type> x(elem);
+                if (x.check())
+                {
+                    container.push_back(x());
+                }
+                else
+                {
+                    PyErr_SetString(PyExc_TypeError, "Incompatible Data Type");
+                    throw_error_already_set();
+                }
+            }
+        }
+    }
+
+}}}
+# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 2
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp" 1
+# 26 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp"
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/boost_headers.hpp" 1
+# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/declare_qflags.hpp" 2
+
+namespace PySide
+{
+
+template< typename FLAG >
+void __attribute__ ((visibility("internal"))) declare_qflags(const char *flag_name)
+{
+    boost::python::class_< FLAG >(flag_name, boost::python::init<const FLAG&>())
+        .def(boost::python::init< boost::python::optional< int > >())
+        .def(boost::python::init< typename FLAG::enum_type >())
+        .def(boost::python::self & int())
+        .def(boost::python::self == boost::python::self)
+        .def(boost::python::self == int())
+        .def(boost::python::self &= int())
+
+        .def(int_(boost::python::self))
+
+        .def(~boost::python::self)
+        .def(boost::python::self |= boost::python::self)
+        .def(boost::python::self ^= boost::python::self)
+        .def(boost::python::self != boost::python::self)
+        .def(!boost::python::self)
+        .def(boost::python::self | boost::python::self)
+        .def(boost::python::self ^ boost::python::self)
+
+        ;
+
+
+    boost::python::implicitly_convertible<int, FLAG >();
+}
+
+template< typename FLAG >
+void __attribute__ ((visibility("internal"))) declare_int_qflags(const char *flag_name)
+{
+    boost::python::class_< FLAG >(flag_name, boost::python::init<const FLAG&>())
+        .def(boost::python::init< boost::python::optional< int > >())
+        .def(boost::python::init< typename FLAG::enum_type >())
+        .def(boost::python::self & int())
+        .def(boost::python::self &= int())
+
+        .def(int_(boost::python::self))
+
+        .def(~boost::python::self)
+        .def(boost::python::self |= boost::python::self)
+        .def(boost::python::self ^= boost::python::self)
+        .def(!boost::python::self)
+        .def(boost::python::self | boost::python::self)
+        .def(boost::python::self ^ boost::python::self)
+
+        ;
+
+
+    boost::python::implicitly_convertible<typename FLAG::enum_type, FLAG >();
+}
+
+};
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 1
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 1 3
+# 41 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+       
+# 42 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 3
+
+
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/stddef.h" 1 3 4
+# 45 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include/g++-v4/cstddef" 2 3
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 2
+
+
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 1
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp"
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp" 1
+# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp"
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp" 2
+
+
+# 1 "/usr/include/qt4/QtCore/QStringList" 1
+# 1 "/usr/include/qt4/QtCore/qstringlist.h" 1
+# 1 "/usr/include/qt4/QtCore/QStringList" 2
+# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/wrapper.hpp" 2
+
+namespace PySide
+{
+
+class __attribute__ ((visibility("default"))) wrapper
+{
+    public:
+        PyObject* py_object() { return m_self; }
+        void keep_cpp_ref();
+        virtual ~wrapper();
+
+    protected:
+        wrapper(PyObject *self);
+        boost::python::object get_override(const char* base_class_name, const char* method_name) const;
+
+    private:
+        wrapper() {}
+        wrapper(wrapper &) {}
+
+        PyObject *m_self;
+        bool m_has_cpp_ref;
+};
+
+}
+# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2
+
+# 1 "/usr/include/qt4/QtCore/QHash" 1
+# 1 "/usr/include/qt4/QtCore/qhash.h" 1
+# 51 "/usr/include/qt4/QtCore/qhash.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QBitArray;
+class QByteArray;
+class QString;
+class QStringRef;
+
+inline uint qHash(char key) { return uint(key); }
+inline uint qHash(uchar key) { return uint(key); }
+inline uint qHash(signed char key) { return uint(key); }
+inline uint qHash(ushort key) { return uint(key); }
+inline uint qHash(short key) { return uint(key); }
+inline uint qHash(uint key) { return key; }
+inline uint qHash(int key) { return uint(key); }
+inline uint qHash(ulong key)
+{
+    if (sizeof(ulong) > sizeof(uint)) {
+        return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U));
+    } else {
+        return uint(key & (~0U));
+    }
+}
+inline uint qHash(long key) { return qHash(ulong(key)); }
+inline uint qHash(quint64 key)
+{
+    if (sizeof(quint64) > sizeof(uint)) {
+        return uint(((key >> (8 * sizeof(uint) - 1)) ^ key) & (~0U));
+    } else {
+        return uint(key & (~0U));
+    }
+}
+inline uint qHash(qint64 key) { return qHash(quint64(key)); }
+inline uint qHash(QChar key) { return qHash(key.unicode()); }
+ uint qHash(const QByteArray &key);
+ uint qHash(const QString &key);
+ uint qHash(const QStringRef &key);
+ uint qHash(const QBitArray &key);
+
+
+
+
+
+template <class T> inline uint qHash(const T *key)
+{
+    return qHash(reinterpret_cast<quintptr>(key));
+}
+
+
+
+
+template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key)
+{
+    uint h1 = qHash(key.first);
+    uint h2 = qHash(key.second);
+    return ((h1 << 16) | (h1 >> 16)) ^ h2;
+}
+
+struct QHashData
+{
+    struct Node {
+        Node *next;
+        uint h;
+    };
+
+    Node *fakeNext;
+    Node **buckets;
+    QBasicAtomicInt ref;
+    int size;
+    int nodeSize;
+    short userNumBits;
+    short numBits;
+    int numBuckets;
+    uint sharable : 1;
+    uint strictAlignment : 1;
+    uint reserved : 30;
+
+    void *allocateNode();
+    void *allocateNode(int nodeAlign);
+    void freeNode(void *node);
+    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize);
+    QHashData *detach_helper2(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
+                              int nodeSize, int nodeAlign);
+    void mightGrow();
+    bool willGrow();
+    void hasShrunk();
+    void rehash(int hint);
+    void free_helper(void (*node_delete)(Node *));
+    void destroyAndFree();
+    Node *firstNode();
+
+
+
+
+    static Node *nextNode(Node *node);
+    static Node *previousNode(Node *node);
+
+    static QHashData shared_null;
+};
+
+inline void QHashData::mightGrow()
+{
+    if (size >= numBuckets)
+        rehash(numBits + 1);
+}
+
+inline bool QHashData::willGrow()
+{
+    if (size >= numBuckets) {
+        rehash(numBits + 1);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+inline void QHashData::hasShrunk()
+{
+    if (size <= (numBuckets >> 3) && numBits > userNumBits) {
+        try {
+            rehash(qMax(int(numBits) - 2, int(userNumBits)));
+        } catch (const std::bad_alloc &) {
+
+        }
+    }
+}
+
+inline QHashData::Node *QHashData::firstNode()
+{
+    Node *e = reinterpret_cast<Node *>(this);
+    Node **bucket = buckets;
+    int n = numBuckets;
+    while (n--) {
+        if (*bucket != e)
+            return *bucket;
+        ++bucket;
+    }
+    return e;
+}
+
+struct QHashDummyValue
+{
+};
+
+inline bool operator==(const QHashDummyValue & , const QHashDummyValue & )
+{
+    return true;
+}
+
+template <> class QTypeInfo<QHashDummyValue > { public: enum { isComplex = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QHashDummyValue)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QHashDummyValue"; } };
+
+template <class Key, class T>
+struct QHashDummyNode
+{
+    QHashDummyNode *next;
+    uint h;
+    Key key;
+
+    inline QHashDummyNode(const Key &key0) : key(key0) {}
+};
+
+template <class Key, class T>
+struct QHashNode
+{
+    QHashNode *next;
+    uint h;
+    Key key;
+    T value;
+
+    inline QHashNode(const Key &key0) : key(key0) {}
+    inline QHashNode(const Key &key0, const T &value0) : key(key0), value(value0) {}
+    inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; }
+};
+# 250 "/usr/include/qt4/QtCore/qhash.h"
+template <class T> struct QHashDummyNode<short, T> { QHashDummyNode *next; union { uint h; short key; }; inline QHashDummyNode(short ) {} }; template <class T> struct QHashNode<short, T> { QHashNode *next; union { uint h; short key; }; T value; inline QHashNode(short ) {} inline QHashNode(short , const T &value0) : value(value0) {} inline bool same_key(uint h0, short) { return h0 == h; } };
+template <class T> struct QHashDummyNode<ushort, T> { QHashDummyNode *next; union { uint h; ushort key; }; inline QHashDummyNode(ushort ) {} }; template <class T> struct QHashNode<ushort, T> { QHashNode *next; union { uint h; ushort key; }; T value; inline QHashNode(ushort ) {} inline QHashNode(ushort , const T &value0) : value(value0) {} inline bool same_key(uint h0, ushort) { return h0 == h; } };
+
+template <class T> struct QHashDummyNode<int, T> { QHashDummyNode *next; union { uint h; int key; }; inline QHashDummyNode(int ) {} }; template <class T> struct QHashNode<int, T> { QHashNode *next; union { uint h; int key; }; T value; inline QHashNode(int ) {} inline QHashNode(int , const T &value0) : value(value0) {} inline bool same_key(uint h0, int) { return h0 == h; } };
+template <class T> struct QHashDummyNode<uint, T> { QHashDummyNode *next; union { uint h; uint key; }; inline QHashDummyNode(uint ) {} }; template <class T> struct QHashNode<uint, T> { QHashNode *next; union { uint h; uint key; }; T value; inline QHashNode(uint ) {} inline QHashNode(uint , const T &value0) : value(value0) {} inline bool same_key(uint h0, uint) { return h0 == h; } };
+
+
+
+template <class Key, class T>
+class QHash
+{
+    typedef QHashDummyNode<Key, T> DummyNode;
+    typedef QHashNode<Key, T> Node;
+
+    union {
+        QHashData *d;
+        QHashNode<Key, T> *e;
+    };
+
+    static inline Node *concrete(QHashData::Node *node) {
+        return reinterpret_cast<Node *>(node);
+    }
+
+
+    static inline int alignOfNode() { return qMax<int>(sizeof(void*), __alignof__(Node)); }
+    static inline int alignOfDummyNode() { return qMax<int>(sizeof(void*), __alignof__(DummyNode)); }
+
+
+
+
+
+public:
+    inline QHash() : d(&QHashData::shared_null) { d->ref.ref(); }
+    inline QHash(const QHash<Key, T> &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); }
+    inline ~QHash() { if (!d->ref.deref()) freeData(d); }
+
+    QHash<Key, T> &operator=(const QHash<Key, T> &other);
+
+    bool operator==(const QHash<Key, T> &other) const;
+    inline bool operator!=(const QHash<Key, T> &other) const { return !(*this == other); }
+
+    inline int size() const { return d->size; }
+
+    inline bool isEmpty() const { return d->size == 0; }
+
+    inline int capacity() const { return d->numBuckets; }
+    void reserve(int size);
+    inline void squeeze() { reserve(1); }
+
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+
+    void clear();
+
+    int remove(const Key &key);
+    T take(const Key &key);
+
+    bool contains(const Key &key) const;
+    const Key key(const T &value) const;
+    const Key key(const T &value, const Key &defaultKey) const;
+    const T value(const Key &key) const;
+    const T value(const Key &key, const T &defaultValue) const;
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+
+    QList<Key> uniqueKeys() const;
+    QList<Key> keys() const;
+    QList<Key> keys(const T &value) const;
+    QList<T> values() const;
+    QList<T> values(const Key &key) const;
+    int count(const Key &key) const;
+
+    class const_iterator;
+
+    class iterator
+    {
+        friend class const_iterator;
+        QHashData::Node *i;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef T *pointer;
+        typedef T &reference;
+
+
+        inline operator Node *() const { return concrete(i); }
+        inline iterator() : i(0) { }
+        explicit inline iterator(void *node) : i(reinterpret_cast<QHashData::Node *>(node)) { }
+
+        inline const Key &key() const { return concrete(i)->key; }
+        inline T &value() const { return concrete(i)->value; }
+        inline T &operator*() const { return concrete(i)->value; }
+        inline T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+
+        inline iterator &operator++() {
+            i = QHashData::nextNode(i);
+            return *this;
+        }
+        inline iterator operator++(int) {
+            iterator r = *this;
+            i = QHashData::nextNode(i);
+            return r;
+        }
+        inline iterator &operator--() {
+            i = QHashData::previousNode(i);
+            return *this;
+        }
+        inline iterator operator--(int) {
+            iterator r = *this;
+            i = QHashData::previousNode(i);
+            return r;
+        }
+        inline iterator operator+(int j) const
+        { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline iterator operator-(int j) const { return operator+(-j); }
+        inline iterator &operator+=(int j) { return *this = *this + j; }
+        inline iterator &operator-=(int j) { return *this = *this - j; }
+
+
+
+
+
+    public:
+
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+
+    private:
+
+        inline operator bool() const { return false; }
+    };
+    friend class iterator;
+
+    class const_iterator
+    {
+        friend class iterator;
+        QHashData::Node *i;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+
+
+        inline operator Node *() const { return concrete(i); }
+        inline const_iterator() : i(0) { }
+        explicit inline const_iterator(void *node)
+            : i(reinterpret_cast<QHashData::Node *>(node)) { }
+
+
+
+        inline const_iterator(const iterator &o)
+
+        { i = o.i; }
+
+        inline const Key &key() const { return concrete(i)->key; }
+        inline const T &value() const { return concrete(i)->value; }
+        inline const T &operator*() const { return concrete(i)->value; }
+        inline const T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+
+        inline const_iterator &operator++() {
+            i = QHashData::nextNode(i);
+            return *this;
+        }
+        inline const_iterator operator++(int) {
+            const_iterator r = *this;
+            i = QHashData::nextNode(i);
+            return r;
+        }
+        inline const_iterator &operator--() {
+            i = QHashData::previousNode(i);
+            return *this;
+        }
+        inline const_iterator operator--(int) {
+            const_iterator r = *this;
+            i = QHashData::previousNode(i);
+            return r;
+        }
+        inline const_iterator operator+(int j) const
+        { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline const_iterator operator-(int j) const { return operator+(-j); }
+        inline const_iterator &operator+=(int j) { return *this = *this + j; }
+        inline const_iterator &operator-=(int j) { return *this = *this - j; }
+# 452 "/usr/include/qt4/QtCore/qhash.h"
+    private:
+
+        inline operator bool() const { return false; }
+    };
+    friend class const_iterator;
+
+
+    inline iterator begin() { detach(); return iterator(d->firstNode()); }
+    inline const_iterator begin() const { return const_iterator(d->firstNode()); }
+    inline const_iterator constBegin() const { return const_iterator(d->firstNode()); }
+    inline iterator end() { detach(); return iterator(e); }
+    inline const_iterator end() const { return const_iterator(e); }
+    inline const_iterator constEnd() const { return const_iterator(e); }
+    iterator erase(iterator it);
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return d->size; }
+    iterator find(const Key &key);
+    const_iterator find(const Key &key) const;
+    const_iterator constFind(const Key &key) const;
+    iterator insert(const Key &key, const T &value);
+    iterator insertMulti(const Key &key, const T &value);
+    QHash<Key, T> &unite(const QHash<Key, T> &other);
+
+
+    typedef T mapped_type;
+    typedef Key key_type;
+    typedef ptrdiff_t difference_type;
+    typedef int size_type;
+
+    inline bool empty() const { return isEmpty(); }
+
+
+
+
+
+
+private:
+    void detach_helper();
+    void freeData(QHashData *d);
+    Node **findNode(const Key &key, uint *hp = 0) const;
+    Node *createNode(uint h, const Key &key, const T &value, Node **nextNode);
+    void deleteNode(Node *node);
+    static void deleteNode2(QHashData::Node *node);
+
+    static void duplicateNode(QHashData::Node *originalNode, void *newNode);
+};
+
+
+template <class Key, class T>
+inline void QHash<Key, T>::deleteNode(Node *node)
+{
+    deleteNode2(reinterpret_cast<QHashData::Node*>(node));
+    d->freeNode(node);
+}
+
+template <class Key, class T>
+inline void QHash<Key, T>::deleteNode2(QHashData::Node *node)
+{
+
+
+
+
+
+    concrete(node)->~Node();
+
+}
+
+template <class Key, class T>
+inline void QHash<Key, T>::duplicateNode(QHashData::Node *node, void *newNode)
+{
+    Node *concreteNode = concrete(node);
+    if (QTypeInfo<T>::isDummy) {
+        (void) new (newNode) DummyNode(concreteNode->key);
+    } else {
+        (void) new (newNode) Node(concreteNode->key, concreteNode->value);
+    }
+}
+
+template <class Key, class T>
+inline typename QHash<Key, T>::Node *
+QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anextNode)
+{
+    Node *node;
+
+    if (QTypeInfo<T>::isDummy) {
+        node = reinterpret_cast<Node *>(new (d->allocateNode(alignOfDummyNode())) DummyNode(akey));
+    } else {
+        node = new (d->allocateNode(alignOfNode())) Node(akey, avalue);
+    }
+
+    node->h = ah;
+    node->next = *anextNode;
+    *anextNode = node;
+    ++d->size;
+    return node;
+}
+
+template <class Key, class T>
+inline QHash<Key, T> &QHash<Key, T>::unite(const QHash<Key, T> &other)
+{
+    QHash<Key, T> copy(other);
+    const_iterator it = copy.constEnd();
+    while (it != copy.constBegin()) {
+        --it;
+        insertMulti(it.key(), it.value());
+    }
+    return *this;
+}
+
+template <class Key, class T>
+ void QHash<Key, T>::freeData(QHashData *x)
+{
+    x->free_helper(deleteNode2);
+}
+
+template <class Key, class T>
+inline void QHash<Key, T>::clear()
+{
+    *this = QHash<Key,T>();
+}
+
+template <class Key, class T>
+ void QHash<Key, T>::detach_helper()
+{
+    QHashData *x = d->detach_helper2(duplicateNode, deleteNode2,
+        QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node),
+        QTypeInfo<T>::isDummy ? alignOfDummyNode() : alignOfNode());
+    if (!d->ref.deref())
+        freeData(d);
+    d = x;
+}
+
+template <class Key, class T>
+inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash<Key, T> &other)
+{
+    if (d != other.d) {
+        other.d->ref.ref();
+        if (!d->ref.deref())
+            freeData(d);
+        d = other.d;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+
+template <class Key, class T>
+inline const T QHash<Key, T>::value(const Key &akey) const
+{
+    Node *node;
+    if (d->size == 0 || (node = *findNode(akey)) == e) {
+        return T();
+    } else {
+        return node->value;
+    }
+}
+
+template <class Key, class T>
+inline const T QHash<Key, T>::value(const Key &akey, const T &adefaultValue) const
+{
+    Node *node;
+    if (d->size == 0 || (node = *findNode(akey)) == e) {
+        return adefaultValue;
+    } else {
+        return node->value;
+    }
+}
+
+template <class Key, class T>
+ QList<Key> QHash<Key, T>::uniqueKeys() const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    if (i != end()) {
+        for (;;) {
+            const Key &aKey = i.key();
+            res.append(aKey);
+            do {
+                if (++i == end())
+                    goto break_out_of_outer_loop;
+            } while (aKey == i.key());
+        }
+    }
+break_out_of_outer_loop:
+    return res;
+}
+
+template <class Key, class T>
+ QList<Key> QHash<Key, T>::keys() const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+
+template <class Key, class T>
+ QList<Key> QHash<Key, T>::keys(const T &avalue) const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+
+template <class Key, class T>
+ const Key QHash<Key, T>::key(const T &avalue) const
+{
+    return key(avalue, Key());
+}
+
+template <class Key, class T>
+ const Key QHash<Key, T>::key(const T &avalue, const Key &defaultValue) const
+{
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            return i.key();
+        ++i;
+    }
+
+    return defaultValue;
+}
+
+template <class Key, class T>
+ QList<T> QHash<Key, T>::values() const
+{
+    QList<T> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.value());
+        ++i;
+    }
+    return res;
+}
+
+template <class Key, class T>
+ QList<T> QHash<Key, T>::values(const Key &akey) const
+{
+    QList<T> res;
+    Node *node = *findNode(akey);
+    if (node != e) {
+        do {
+            res.append(node->value);
+        } while ((node = node->next) != e && node->key == akey);
+    }
+    return res;
+}
+
+template <class Key, class T>
+ int QHash<Key, T>::count(const Key &akey) const
+{
+    int cnt = 0;
+    Node *node = *findNode(akey);
+    if (node != e) {
+        do {
+            ++cnt;
+        } while ((node = node->next) != e && node->key == akey);
+    }
+    return cnt;
+}
+
+template <class Key, class T>
+inline const T QHash<Key, T>::operator[](const Key &akey) const
+{
+    return value(akey);
+}
+
+template <class Key, class T>
+inline T &QHash<Key, T>::operator[](const Key &akey)
+{
+    detach();
+
+    uint h;
+    Node **node = findNode(akey, &h);
+    if (*node == e) {
+        if (d->willGrow())
+            node = findNode(akey, &h);
+        return createNode(h, akey, T(), node)->value;
+    }
+    return (*node)->value;
+}
+
+template <class Key, class T>
+inline typename QHash<Key, T>::iterator QHash<Key, T>::insert(const Key &akey,
+                                                                         const T &avalue)
+{
+    detach();
+
+    uint h;
+    Node **node = findNode(akey, &h);
+    if (*node == e) {
+        if (d->willGrow())
+            node = findNode(akey, &h);
+        return iterator(createNode(h, akey, avalue, node));
+    }
+
+    if (!QTypeInfo<T>::isDummy)
+        (*node)->value = avalue;
+    return iterator(*node);
+}
+
+template <class Key, class T>
+inline typename QHash<Key, T>::iterator QHash<Key, T>::insertMulti(const Key &akey,
+                                                                              const T &avalue)
+{
+    detach();
+    d->willGrow();
+
+    uint h;
+    Node **nextNode = findNode(akey, &h);
+    return iterator(createNode(h, akey, avalue, nextNode));
+}
+
+template <class Key, class T>
+ int QHash<Key, T>::remove(const Key &akey)
+{
+    if (isEmpty())
+        return 0;
+    detach();
+
+    int oldSize = d->size;
+    Node **node = findNode(akey);
+    if (*node != e) {
+        bool deleteNext = true;
+        do {
+            Node *next = (*node)->next;
+            deleteNext = (next != e && next->key == (*node)->key);
+            deleteNode(*node);
+            *node = next;
+            --d->size;
+        } while (deleteNext);
+        d->hasShrunk();
+    }
+    return oldSize - d->size;
+}
+
+template <class Key, class T>
+ T QHash<Key, T>::take(const Key &akey)
+{
+    if (isEmpty())
+        return T();
+    detach();
+
+    Node **node = findNode(akey);
+    if (*node != e) {
+        T t = (*node)->value;
+        Node *next = (*node)->next;
+        deleteNode(*node);
+        *node = next;
+        --d->size;
+        d->hasShrunk();
+        return t;
+    }
+    return T();
+}
+
+template <class Key, class T>
+ typename QHash<Key, T>::iterator QHash<Key, T>::erase(iterator it)
+{
+    if (it == iterator(e))
+        return it;
+
+    iterator ret = it;
+    ++ret;
+
+    Node *node = it;
+    Node **node_ptr = reinterpret_cast<Node **>(&d->buckets[node->h % d->numBuckets]);
+    while (*node_ptr != node)
+        node_ptr = &(*node_ptr)->next;
+    *node_ptr = node->next;
+    deleteNode(node);
+    --d->size;
+    return ret;
+}
+
+template <class Key, class T>
+inline void QHash<Key, T>::reserve(int asize)
+{
+    detach();
+    d->rehash(-qMax(asize, 1));
+}
+
+template <class Key, class T>
+inline typename QHash<Key, T>::const_iterator QHash<Key, T>::find(const Key &akey) const
+{
+    return const_iterator(*findNode(akey));
+}
+
+template <class Key, class T>
+inline typename QHash<Key, T>::const_iterator QHash<Key, T>::constFind(const Key &akey) const
+{
+    return const_iterator(*findNode(akey));
+}
+
+template <class Key, class T>
+inline typename QHash<Key, T>::iterator QHash<Key, T>::find(const Key &akey)
+{
+    detach();
+    return iterator(*findNode(akey));
+}
+
+template <class Key, class T>
+inline bool QHash<Key, T>::contains(const Key &akey) const
+{
+    return *findNode(akey) != e;
+}
+
+template <class Key, class T>
+ typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey,
+                                                                            uint *ahp) const
+{
+    Node **node;
+    uint h = qHash(akey);
+
+    if (d->numBuckets) {
+        node = reinterpret_cast<Node **>(&d->buckets[h % d->numBuckets]);
+        ((!(*node == e || (*node)->next)) ? qt_assert("*node == e || (*node)->next","/usr/include/qt4/QtCore/qhash.h",879) : qt_noop());
+        while (*node != e && !(*node)->same_key(h, akey))
+            node = &(*node)->next;
+    } else {
+        node = const_cast<Node **>(reinterpret_cast<const Node * const *>(&e));
+    }
+    if (ahp)
+        *ahp = h;
+    return node;
+}
+
+template <class Key, class T>
+ bool QHash<Key, T>::operator==(const QHash<Key, T> &other) const
+{
+    if (size() != other.size())
+        return false;
+    if (d == other.d)
+        return true;
+
+    const_iterator it = begin();
+
+    while (it != end()) {
+        const Key &akey = it.key();
+
+        const_iterator it2 = other.find(akey);
+        do {
+            if (it2 == other.end() || !(it2.key() == akey))
+                return false;
+            if (!QTypeInfo<T>::isDummy && !(it.value() == it2.value()))
+                return false;
+            ++it;
+            ++it2;
+        } while (it != end() && it.key() == akey);
+    }
+    return true;
+}
+
+template <class Key, class T>
+class QMultiHash : public QHash<Key, T>
+{
+public:
+    QMultiHash() {}
+    QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {}
+
+    inline typename QHash<Key, T>::iterator replace(const Key &key, const T &value)
+    { return QHash<Key, T>::insert(key, value); }
+
+    inline typename QHash<Key, T>::iterator insert(const Key &key, const T &value)
+    { return QHash<Key, T>::insertMulti(key, value); }
+
+    inline QMultiHash &operator+=(const QMultiHash &other)
+    { unite(other); return *this; }
+    inline QMultiHash operator+(const QMultiHash &other) const
+    { QMultiHash result = *this; result += other; return result; }
+
+
+
+    using QHash<Key, T>::contains;
+    using QHash<Key, T>::remove;
+    using QHash<Key, T>::count;
+    using QHash<Key, T>::find;
+    using QHash<Key, T>::constFind;
+# 958 "/usr/include/qt4/QtCore/qhash.h"
+    bool contains(const Key &key, const T &value) const;
+
+    int remove(const Key &key, const T &value);
+
+    int count(const Key &key, const T &value) const;
+
+    typename QHash<Key, T>::iterator find(const Key &key, const T &value) {
+        typename QHash<Key, T>::iterator i(find(key));
+        typename QHash<Key, T>::iterator end(this->end());
+        while (i != end && i.key() == key) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QHash<Key, T>::const_iterator find(const Key &key, const T &value) const {
+        typename QHash<Key, T>::const_iterator i(constFind(key));
+        typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
+        while (i != end && i.key() == key) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QHash<Key, T>::const_iterator constFind(const Key &key, const T &value) const
+        { return find(key, value); }
+private:
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+};
+
+template <class Key, class T>
+inline bool QMultiHash<Key, T>::contains(const Key &key, const T &value) const
+{
+    return constFind(key, value) != QHash<Key, T>::constEnd();
+}
+
+template <class Key, class T>
+inline int QMultiHash<Key, T>::remove(const Key &key, const T &value)
+{
+    int n = 0;
+    typename QHash<Key, T>::iterator i(find(key));
+    typename QHash<Key, T>::iterator end(QHash<Key, T>::end());
+    while (i != end && i.key() == key) {
+        if (i.value() == value) {
+
+
+
+
+            i = erase(i);
+
+            ++n;
+        } else {
+            ++i;
+        }
+    }
+    return n;
+}
+
+template <class Key, class T>
+inline int QMultiHash<Key, T>::count(const Key &key, const T &value) const
+{
+    int n = 0;
+    typename QHash<Key, T>::const_iterator i(constFind(key));
+    typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd());
+    while (i != end && i.key() == key) {
+        if (i.value() == value)
+            ++n;
+        ++i;
+    }
+    return n;
+}
+
+template <class Key, class T> class QHashIterator { typedef typename QHash<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QHash<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QHashIterator(const QHash<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QHashIterator &operator=(const QHash<Key,T> &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1033) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1033) : qt_noop()); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } };
+template <class Key, class T> class QMutableHashIterator { typedef typename QHash<Key,T>::iterator iterator; typedef typename QHash<Key,T>::const_iterator const_iterator; typedef iterator Item; QHash<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableHashIterator(QHash<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableHashIterator() { c->setSharable(true); } inline QMutableHashIterator &operator=(QHash<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1034) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1034) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qhash.h",1034) : qt_noop()); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+
+
+
+
+# 1 "/usr/include/qt4/QtCore/QHash" 2
+# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QDebug" 1
+# 1 "/usr/include/qt4/QtCore/qdebug.h" 1
+# 46 "/usr/include/qt4/QtCore/qdebug.h"
+# 1 "/usr/include/qt4/QtCore/qhash.h" 1
+# 47 "/usr/include/qt4/QtCore/qdebug.h" 2
+
+# 1 "/usr/include/qt4/QtCore/qmap.h" 1
+# 55 "/usr/include/qt4/QtCore/qmap.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+struct QMapData
+{
+    struct Node {
+        Node *backward;
+        Node *forward[1];
+    };
+    enum { LastLevel = 11, Sparseness = 3 };
+
+    QMapData *backward;
+    QMapData *forward[QMapData::LastLevel + 1];
+    QBasicAtomicInt ref;
+    int topLevel;
+    int size;
+    uint randomBits;
+    uint insertInOrder : 1;
+    uint sharable : 1;
+    uint strictAlignment : 1;
+    uint reserved : 29;
+
+    static QMapData *createData();
+    static QMapData *createData(int alignment);
+    void continueFreeData(int offset);
+    Node *node_create(Node *update[], int offset);
+    Node *node_create(Node *update[], int offset, int alignment);
+    void node_delete(Node *update[], int offset, Node *node);
+
+
+
+
+
+    static QMapData shared_null;
+};
+# 105 "/usr/include/qt4/QtCore/qmap.h"
+template <class Key> inline bool qMapLessThanKey(const Key &key1, const Key &key2)
+{
+    return key1 < key2;
+}
+
+
+template <class Ptr> inline bool qMapLessThanKey(Ptr *key1, Ptr *key2)
+{
+    ((!(sizeof(quintptr) == sizeof(Ptr *))) ? qt_assert("sizeof(quintptr) == sizeof(Ptr *)","/usr/include/qt4/QtCore/qmap.h",113) : qt_noop());
+    return quintptr(key1) < quintptr(key2);
+}
+
+template <class Ptr> inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2)
+{
+    ((!(sizeof(quintptr) == sizeof(const Ptr *))) ? qt_assert("sizeof(quintptr) == sizeof(const Ptr *)","/usr/include/qt4/QtCore/qmap.h",119) : qt_noop());
+    return quintptr(key1) < quintptr(key2);
+}
+
+
+template <class Key, class T>
+struct QMapNode {
+    Key key;
+    T value;
+    QMapData::Node *backward;
+    QMapData::Node *forward[1];
+};
+
+template <class Key, class T>
+struct QMapPayloadNode
+{
+    Key key;
+    T value;
+    QMapData::Node *backward;
+};
+
+template <class Key, class T>
+class QMap
+{
+    typedef QMapNode<Key, T> Node;
+    typedef QMapPayloadNode<Key, T> PayloadNode;
+
+    union {
+        QMapData *d;
+        QMapData::Node *e;
+    };
+
+    static inline int payload() { return sizeof(PayloadNode) - sizeof(QMapData::Node *); }
+    static inline int alignment() {
+
+        return int(qMax(sizeof(void*), __alignof__(Node)));
+
+
+
+    }
+    static inline Node *concrete(QMapData::Node *node) {
+        return reinterpret_cast<Node *>(reinterpret_cast<char *>(node) - payload());
+    }
+
+public:
+    inline QMap() : d(&QMapData::shared_null) { d->ref.ref(); }
+    inline QMap(const QMap<Key, T> &other) : d(other.d)
+    { d->ref.ref(); if (!d->sharable) detach(); }
+    inline ~QMap() { if (!d) return; if (!d->ref.deref()) freeData(d); }
+
+    QMap<Key, T> &operator=(const QMap<Key, T> &other);
+
+    explicit QMap(const typename std::map<Key, T> &other);
+    std::map<Key, T> toStdMap() const;
+
+
+    bool operator==(const QMap<Key, T> &other) const;
+    inline bool operator!=(const QMap<Key, T> &other) const { return !(*this == other); }
+
+    inline int size() const { return d->size; }
+
+    inline bool isEmpty() const { return d->size == 0; }
+
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+    inline void setInsertInOrder(bool ordered) { d->insertInOrder = ordered; }
+
+    void clear();
+
+    int remove(const Key &key);
+    T take(const Key &key);
+
+    bool contains(const Key &key) const;
+    const Key key(const T &value) const;
+    const Key key(const T &value, const Key &defaultKey) const;
+    const T value(const Key &key) const;
+    const T value(const Key &key, const T &defaultValue) const;
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+
+    QList<Key> uniqueKeys() const;
+    QList<Key> keys() const;
+    QList<Key> keys(const T &value) const;
+    QList<T> values() const;
+    QList<T> values(const Key &key) const;
+    int count(const Key &key) const;
+
+    class const_iterator;
+
+    class iterator
+    {
+        friend class const_iterator;
+        QMapData::Node *i;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef T *pointer;
+        typedef T &reference;
+
+
+        inline operator QMapData::Node *() const { return i; }
+        inline iterator() : i(0) { }
+        inline iterator(QMapData::Node *node) : i(node) { }
+
+        inline const Key &key() const { return concrete(i)->key; }
+        inline T &value() const { return concrete(i)->value; }
+
+
+
+        inline T &operator*() const { return concrete(i)->value; }
+        inline T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+
+        inline iterator &operator++() {
+            i = i->forward[0];
+            return *this;
+        }
+        inline iterator operator++(int) {
+            iterator r = *this;
+            i = i->forward[0];
+            return r;
+        }
+        inline iterator &operator--() {
+            i = i->backward;
+            return *this;
+        }
+        inline iterator operator--(int) {
+            iterator r = *this;
+            i = i->backward;
+            return r;
+        }
+        inline iterator operator+(int j) const
+        { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline iterator operator-(int j) const { return operator+(-j); }
+        inline iterator &operator+=(int j) { return *this = *this + j; }
+        inline iterator &operator-=(int j) { return *this = *this - j; }
+
+
+
+
+
+    public:
+
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+
+    private:
+
+        inline operator bool() const { return false; }
+    };
+    friend class iterator;
+
+    class const_iterator
+    {
+        friend class iterator;
+        QMapData::Node *i;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+
+
+        inline operator QMapData::Node *() const { return i; }
+        inline const_iterator() : i(0) { }
+        inline const_iterator(QMapData::Node *node) : i(node) { }
+
+
+
+        inline const_iterator(const iterator &o)
+
+        { i = o.i; }
+
+        inline const Key &key() const { return concrete(i)->key; }
+        inline const T &value() const { return concrete(i)->value; }
+
+
+
+        inline const T &operator*() const { return concrete(i)->value; }
+        inline const T *operator->() const { return &concrete(i)->value; }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+
+        inline const_iterator &operator++() {
+            i = i->forward[0];
+            return *this;
+        }
+        inline const_iterator operator++(int) {
+            const_iterator r = *this;
+            i = i->forward[0];
+            return r;
+        }
+        inline const_iterator &operator--() {
+            i = i->backward;
+            return *this;
+        }
+        inline const_iterator operator--(int) {
+            const_iterator r = *this;
+            i = i->backward;
+            return r;
+        }
+        inline const_iterator operator+(int j) const
+        { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; }
+        inline const_iterator operator-(int j) const { return operator+(-j); }
+        inline const_iterator &operator+=(int j) { return *this = *this + j; }
+        inline const_iterator &operator-=(int j) { return *this = *this - j; }
+# 341 "/usr/include/qt4/QtCore/qmap.h"
+    private:
+
+        inline operator bool() const { return false; }
+    };
+    friend class const_iterator;
+
+
+    inline iterator begin() { detach(); return iterator(e->forward[0]); }
+    inline const_iterator begin() const { return const_iterator(e->forward[0]); }
+    inline const_iterator constBegin() const { return const_iterator(e->forward[0]); }
+    inline iterator end() {
+        detach();
+        return iterator(e);
+    }
+    inline const_iterator end() const { return const_iterator(e); }
+    inline const_iterator constEnd() const { return const_iterator(e); }
+    iterator erase(iterator it);
+
+
+
+
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return d->size; }
+    iterator find(const Key &key);
+    const_iterator find(const Key &key) const;
+    const_iterator constFind(const Key &key) const;
+    iterator lowerBound(const Key &key);
+    const_iterator lowerBound(const Key &key) const;
+    iterator upperBound(const Key &key);
+    const_iterator upperBound(const Key &key) const;
+    iterator insert(const Key &key, const T &value);
+
+
+
+    iterator insertMulti(const Key &key, const T &value);
+
+
+
+    QMap<Key, T> &unite(const QMap<Key, T> &other);
+
+
+    typedef Key key_type;
+    typedef T mapped_type;
+    typedef ptrdiff_t difference_type;
+    typedef int size_type;
+    inline bool empty() const { return isEmpty(); }
+
+
+
+
+
+private:
+    void detach_helper();
+    void freeData(QMapData *d);
+    QMapData::Node *findNode(const Key &key) const;
+    QMapData::Node *mutableFindNode(QMapData::Node *update[], const Key &key) const;
+    QMapData::Node *node_create(QMapData *d, QMapData::Node *update[], const Key &key,
+                                const T &value);
+};
+
+template <class Key, class T>
+inline QMap<Key, T> &QMap<Key, T>::operator=(const QMap<Key, T> &other)
+{
+    if (d != other.d) {
+        other.d->ref.ref();
+        if (!d->ref.deref())
+            freeData(d);
+        d = other.d;
+        if (!d->sharable)
+            detach_helper();
+    }
+    return *this;
+}
+
+template <class Key, class T>
+inline void QMap<Key, T>::clear()
+{
+    *this = QMap<Key, T>();
+}
+
+template <class Key, class T>
+inline typename QMapData::Node *
+QMap<Key, T>::node_create(QMapData *adt, QMapData::Node *aupdate[], const Key &akey, const T &avalue)
+{
+    QMapData::Node *abstractNode = adt->node_create(aupdate, payload(), alignment());
+    try {
+        Node *concreteNode = concrete(abstractNode);
+        new (&concreteNode->key) Key(akey);
+        try {
+            new (&concreteNode->value) T(avalue);
+        } catch (...) {
+            concreteNode->key.~Key();
+            throw;
+        }
+    } catch (...) {
+        adt->node_delete(aupdate, payload(), abstractNode);
+        throw;
+    }
+# 452 "/usr/include/qt4/QtCore/qmap.h"
+    return abstractNode;
+}
+
+template <class Key, class T>
+inline QMapData::Node *QMap<Key, T>::findNode(const Key &akey) const
+{
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+    }
+
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        return next;
+    } else {
+        return e;
+    }
+}
+
+template <class Key, class T>
+inline const T QMap<Key, T>::value(const Key &akey) const
+{
+    QMapData::Node *node;
+    if (d->size == 0 || (node = findNode(akey)) == e) {
+        return T();
+    } else {
+        return concrete(node)->value;
+    }
+}
+
+template <class Key, class T>
+inline const T QMap<Key, T>::value(const Key &akey, const T &adefaultValue) const
+{
+    QMapData::Node *node;
+    if (d->size == 0 || (node = findNode(akey)) == e) {
+        return adefaultValue;
+    } else {
+        return concrete(node)->value;
+    }
+}
+
+template <class Key, class T>
+inline const T QMap<Key, T>::operator[](const Key &akey) const
+{
+    return value(akey);
+}
+
+template <class Key, class T>
+inline T &QMap<Key, T>::operator[](const Key &akey)
+{
+    detach();
+
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *node = mutableFindNode(update, akey);
+    if (node == e)
+        node = node_create(d, update, akey, T());
+    return concrete(node)->value;
+}
+
+template <class Key, class T>
+inline int QMap<Key, T>::count(const Key &akey) const
+{
+    int cnt = 0;
+    QMapData::Node *node = findNode(akey);
+    if (node != e) {
+        do {
+            ++cnt;
+            node = node->forward[0];
+        } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key));
+    }
+    return cnt;
+}
+
+template <class Key, class T>
+inline bool QMap<Key, T>::contains(const Key &akey) const
+{
+    return findNode(akey) != e;
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey,
+                                                                       const T &avalue)
+{
+    detach();
+
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *node = mutableFindNode(update, akey);
+    if (node == e) {
+        node = node_create(d, update, akey, avalue);
+    } else {
+        concrete(node)->value = avalue;
+    }
+    return iterator(node);
+}
+# 569 "/usr/include/qt4/QtCore/qmap.h"
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::insertMulti(const Key &akey,
+                                                                            const T &avalue)
+{
+    detach();
+
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    mutableFindNode(update, akey);
+    return iterator(node_create(d, update, akey, avalue));
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator QMap<Key, T>::find(const Key &akey) const
+{
+    return const_iterator(findNode(akey));
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator QMap<Key, T>::constFind(const Key &akey) const
+{
+    return const_iterator(findNode(akey));
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::find(const Key &akey)
+{
+    detach();
+    return iterator(findNode(akey));
+}
+
+template <class Key, class T>
+inline QMap<Key, T> &QMap<Key, T>::unite(const QMap<Key, T> &other)
+{
+    QMap<Key, T> copy(other);
+    const_iterator it = copy.constEnd();
+    const const_iterator b = copy.constBegin();
+    while (it != b) {
+        --it;
+        insertMulti(it.key(), it.value());
+    }
+    return *this;
+}
+
+template <class Key, class T>
+ void QMap<Key, T>::freeData(QMapData *x)
+{
+    if (QTypeInfo<Key>::isComplex || QTypeInfo<T>::isComplex) {
+        QMapData *cur = x;
+        QMapData *next = cur->forward[0];
+        while (next != x) {
+            cur = next;
+            next = cur->forward[0];
+
+
+
+            Node *concreteNode = concrete(reinterpret_cast<QMapData::Node *>(cur));
+            concreteNode->key.~Key();
+            concreteNode->value.~T();
+
+
+
+        }
+    }
+    x->continueFreeData(payload());
+}
+
+template <class Key, class T>
+ int QMap<Key, T>::remove(const Key &akey)
+{
+    detach();
+
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+    int oldSize = d->size;
+
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+        update[i] = cur;
+    }
+
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        bool deleteNext = true;
+        do {
+            cur = next;
+            next = cur->forward[0];
+            deleteNext = (next != e && !qMapLessThanKey<Key>(concrete(cur)->key, concrete(next)->key));
+            concrete(cur)->key.~Key();
+            concrete(cur)->value.~T();
+            d->node_delete(update, payload(), cur);
+        } while (deleteNext);
+    }
+    return oldSize - d->size;
+}
+
+template <class Key, class T>
+ T QMap<Key, T>::take(const Key &akey)
+{
+    detach();
+
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+        update[i] = cur;
+    }
+
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        T t = concrete(next)->value;
+        concrete(next)->key.~Key();
+        concrete(next)->value.~T();
+        d->node_delete(update, payload(), next);
+        return t;
+    }
+    return T();
+}
+
+template <class Key, class T>
+ typename QMap<Key, T>::iterator QMap<Key, T>::erase(iterator it)
+{
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+
+    if (it == iterator(e))
+        return it;
+
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, it.key()))
+            cur = next;
+        update[i] = cur;
+    }
+
+    while (next != e) {
+        cur = next;
+        next = cur->forward[0];
+        if (cur == it) {
+            concrete(cur)->key.~Key();
+            concrete(cur)->value.~T();
+            d->node_delete(update, payload(), cur);
+            return iterator(next);
+        }
+
+        for (int i = 0; i <= d->topLevel; ++i) {
+            if (update[i]->forward[i] != cur)
+                break;
+            update[i] = cur;
+        }
+    }
+    return end();
+}
+
+template <class Key, class T>
+ void QMap<Key, T>::detach_helper()
+{
+    union { QMapData *d; QMapData::Node *e; } x;
+    x.d = QMapData::createData(alignment());
+    if (d->size) {
+        x.d->insertInOrder = true;
+        QMapData::Node *update[QMapData::LastLevel + 1];
+        QMapData::Node *cur = e->forward[0];
+        update[0] = x.e;
+        while (cur != e) {
+            try {
+                Node *concreteNode = concrete(cur);
+                node_create(x.d, update, concreteNode->key, concreteNode->value);
+            } catch (...) {
+                freeData(x.d);
+                throw;
+            }
+            cur = cur->forward[0];
+        }
+        x.d->insertInOrder = false;
+    }
+    if (!d->ref.deref())
+        freeData(d);
+    d = x.d;
+}
+
+template <class Key, class T>
+ QMapData::Node *QMap<Key, T>::mutableFindNode(QMapData::Node *aupdate[],
+                                                                   const Key &akey) const
+{
+    QMapData::Node *cur = e;
+    QMapData::Node *next = e;
+
+    for (int i = d->topLevel; i >= 0; i--) {
+        while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey))
+            cur = next;
+        aupdate[i] = cur;
+    }
+    if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) {
+        return next;
+    } else {
+        return e;
+    }
+}
+
+template <class Key, class T>
+ QList<Key> QMap<Key, T>::uniqueKeys() const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    if (i != end()) {
+        for (;;) {
+            const Key &aKey = i.key();
+            res.append(aKey);
+            do {
+                if (++i == end())
+                    goto break_out_of_outer_loop;
+            } while (!(aKey < i.key()));
+        }
+    }
+break_out_of_outer_loop:
+    return res;
+}
+
+template <class Key, class T>
+ QList<Key> QMap<Key, T>::keys() const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+
+template <class Key, class T>
+ QList<Key> QMap<Key, T>::keys(const T &avalue) const
+{
+    QList<Key> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            res.append(i.key());
+        ++i;
+    }
+    return res;
+}
+
+template <class Key, class T>
+ const Key QMap<Key, T>::key(const T &avalue) const
+{
+    return key(avalue, Key());
+}
+
+template <class Key, class T>
+ const Key QMap<Key, T>::key(const T &avalue, const Key &defaultKey) const
+{
+    const_iterator i = begin();
+    while (i != end()) {
+        if (i.value() == avalue)
+            return i.key();
+        ++i;
+    }
+
+    return defaultKey;
+}
+
+template <class Key, class T>
+ QList<T> QMap<Key, T>::values() const
+{
+    QList<T> res;
+    const_iterator i = begin();
+    while (i != end()) {
+        res.append(i.value());
+        ++i;
+    }
+    return res;
+}
+
+template <class Key, class T>
+ QList<T> QMap<Key, T>::values(const Key &akey) const
+{
+    QList<T> res;
+    QMapData::Node *node = findNode(akey);
+    if (node != e) {
+        do {
+            res.append(concrete(node)->value);
+            node = node->forward[0];
+        } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key));
+    }
+    return res;
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator
+QMap<Key, T>::lowerBound(const Key &akey) const
+{
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    mutableFindNode(update, akey);
+    return const_iterator(update[0]->forward[0]);
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::lowerBound(const Key &akey)
+{
+    detach();
+    return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->lowerBound(akey));
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::const_iterator
+QMap<Key, T>::upperBound(const Key &akey) const
+{
+    QMapData::Node *update[QMapData::LastLevel + 1];
+    mutableFindNode(update, akey);
+    QMapData::Node *node = update[0]->forward[0];
+    while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key))
+        node = node->forward[0];
+    return const_iterator(node);
+}
+
+template <class Key, class T>
+inline typename QMap<Key, T>::iterator QMap<Key, T>::upperBound(const Key &akey)
+{
+    detach();
+    return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->upperBound(akey));
+}
+
+template <class Key, class T>
+ bool QMap<Key, T>::operator==(const QMap<Key, T> &other) const
+{
+    if (size() != other.size())
+        return false;
+    if (d == other.d)
+        return true;
+
+    const_iterator it1 = begin();
+    const_iterator it2 = other.begin();
+
+    while (it1 != end()) {
+        if (!(it1.value() == it2.value()) || qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key()))
+            return false;
+        ++it2;
+        ++it1;
+    }
+    return true;
+}
+
+
+template <class Key, class T>
+ QMap<Key, T>::QMap(const std::map<Key, T> &other)
+{
+    d = QMapData::createData(alignment());
+    d->insertInOrder = true;
+    typename std::map<Key,T>::const_iterator it = other.end();
+    while (it != other.begin()) {
+        --it;
+        insert((*it).first, (*it).second);
+    }
+    d->insertInOrder = false;
+}
+
+template <class Key, class T>
+ std::map<Key, T> QMap<Key, T>::toStdMap() const
+{
+    std::map<Key, T> map;
+    const_iterator it = end();
+    while (it != begin()) {
+        --it;
+        map.insert(std::pair<Key, T>(it.key(), it.value()));
+    }
+    return map;
+}
+
+
+
+template <class Key, class T>
+class QMultiMap : public QMap<Key, T>
+{
+public:
+    QMultiMap() {}
+    QMultiMap(const QMap<Key, T> &other) : QMap<Key, T>(other) {}
+
+    inline typename QMap<Key, T>::iterator replace(const Key &key, const T &value)
+    { return QMap<Key, T>::insert(key, value); }
+    inline typename QMap<Key, T>::iterator insert(const Key &key, const T &value)
+    { return QMap<Key, T>::insertMulti(key, value); }
+
+    inline QMultiMap &operator+=(const QMultiMap &other)
+    { unite(other); return *this; }
+    inline QMultiMap operator+(const QMultiMap &other) const
+    { QMultiMap result = *this; result += other; return result; }
+
+
+
+    using QMap<Key, T>::contains;
+    using QMap<Key, T>::remove;
+    using QMap<Key, T>::count;
+    using QMap<Key, T>::find;
+    using QMap<Key, T>::constFind;
+# 984 "/usr/include/qt4/QtCore/qmap.h"
+    bool contains(const Key &key, const T &value) const;
+
+    int remove(const Key &key, const T &value);
+
+    int count(const Key &key, const T &value) const;
+
+    typename QMap<Key, T>::iterator find(const Key &key, const T &value) {
+        typename QMap<Key, T>::iterator i(find(key));
+        typename QMap<Key, T>::iterator end(this->end());
+        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QMap<Key, T>::const_iterator find(const Key &key, const T &value) const {
+        typename QMap<Key, T>::const_iterator i(constFind(key));
+        typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
+        while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+            if (i.value() == value)
+                return i;
+            ++i;
+        }
+        return end;
+    }
+    typename QMap<Key, T>::const_iterator constFind(const Key &key, const T &value) const
+        { return find(key, value); }
+private:
+    T &operator[](const Key &key);
+    const T operator[](const Key &key) const;
+};
+
+template <class Key, class T>
+inline bool QMultiMap<Key, T>::contains(const Key &key, const T &value) const
+{
+    return constFind(key, value) != QMap<Key, T>::constEnd();
+}
+
+template <class Key, class T>
+inline int QMultiMap<Key, T>::remove(const Key &key, const T &value)
+{
+    int n = 0;
+    typename QMap<Key, T>::iterator i(find(key));
+    typename QMap<Key, T>::iterator end(QMap<Key, T>::end());
+    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+        if (i.value() == value) {
+
+
+
+
+            i = erase(i);
+
+            ++n;
+        } else {
+            ++i;
+        }
+    }
+    return n;
+}
+
+template <class Key, class T>
+inline int QMultiMap<Key, T>::count(const Key &key, const T &value) const
+{
+    int n = 0;
+    typename QMap<Key, T>::const_iterator i(constFind(key));
+    typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd());
+    while (i != end && !qMapLessThanKey<Key>(key, i.key())) {
+        if (i.value() == value)
+            ++n;
+        ++i;
+    }
+    return n;
+}
+
+template <class Key, class T> class QMapIterator { typedef typename QMap<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QMap<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QMapIterator(const QMap<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QMapIterator &operator=(const QMap<Key,T> &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1059) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1059) : qt_noop()); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } };
+template <class Key, class T> class QMutableMapIterator { typedef typename QMap<Key,T>::iterator iterator; typedef typename QMap<Key,T>::const_iterator const_iterator; typedef iterator Item; QMap<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableMapIterator(QMap<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableMapIterator() { c->setSharable(true); } inline QMutableMapIterator &operator=(QMap<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1060) : qt_noop()); return *n; } inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1060) : qt_noop()); return *n; } inline const Key &key() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qmap.h",1060) : qt_noop()); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } };
+
+
+
+
+# 49 "/usr/include/qt4/QtCore/qdebug.h" 2
+
+# 1 "/usr/include/qt4/QtCore/qtextstream.h" 1
+# 48 "/usr/include/qt4/QtCore/qtextstream.h"
+# 1 "/usr/include/qt4/QtCore/qlocale.h" 1
+# 48 "/usr/include/qt4/QtCore/qlocale.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QDataStream;
+class QDate;
+class QDateTime;
+class QTime;
+class QVariant;
+class QTextStream;
+class QTextStreamPrivate;
+
+class QLocale;
+
+
+class QSystemLocale
+{
+public:
+    QSystemLocale();
+    virtual ~QSystemLocale();
+
+    enum QueryType {
+        LanguageId,
+        CountryId,
+        DecimalPoint,
+        GroupSeparator,
+        ZeroDigit,
+        NegativeSign,
+        DateFormatLong,
+        DateFormatShort,
+        TimeFormatLong,
+        TimeFormatShort,
+        DayNameLong,
+        DayNameShort,
+        MonthNameLong,
+        MonthNameShort,
+        DateToStringLong,
+        DateToStringShort,
+        TimeToStringLong,
+        TimeToStringShort,
+        DateTimeFormatLong,
+        DateTimeFormatShort,
+        DateTimeToStringLong,
+        DateTimeToStringShort,
+        MeasurementSystem,
+        PositiveSign,
+        AMText,
+        PMText
+    };
+    virtual QVariant query(QueryType type, QVariant in) const;
+    virtual QLocale fallbackLocale() const;
+
+private:
+    QSystemLocale(bool);
+    friend QSystemLocale *QSystemLocale_globalSystemLocale();
+};
+
+
+struct QLocalePrivate;
+class QLocale
+{
+    public: static const QMetaObject staticMetaObject; private:
+   
+   
+    friend class QString;
+    friend class QByteArray;
+    friend class QIntValidator;
+    friend class QDoubleValidator;
+    friend class QTextStream;
+    friend class QTextStreamPrivate;
+
+public:
+    enum Language {
+        C = 1,
+        Abkhazian = 2,
+        Afan = 3,
+        Afar = 4,
+        Afrikaans = 5,
+        Albanian = 6,
+        Amharic = 7,
+        Arabic = 8,
+        Armenian = 9,
+        Assamese = 10,
+        Aymara = 11,
+        Azerbaijani = 12,
+        Bashkir = 13,
+        Basque = 14,
+        Bengali = 15,
+        Bhutani = 16,
+        Bihari = 17,
+        Bislama = 18,
+        Breton = 19,
+        Bulgarian = 20,
+        Burmese = 21,
+        Byelorussian = 22,
+        Cambodian = 23,
+        Catalan = 24,
+        Chinese = 25,
+        Corsican = 26,
+        Croatian = 27,
+        Czech = 28,
+        Danish = 29,
+        Dutch = 30,
+        English = 31,
+        Esperanto = 32,
+        Estonian = 33,
+        Faroese = 34,
+        FijiLanguage = 35,
+        Finnish = 36,
+        French = 37,
+        Frisian = 38,
+        Gaelic = 39,
+        Galician = 40,
+        Georgian = 41,
+        German = 42,
+        Greek = 43,
+        Greenlandic = 44,
+        Guarani = 45,
+        Gujarati = 46,
+        Hausa = 47,
+        Hebrew = 48,
+        Hindi = 49,
+        Hungarian = 50,
+        Icelandic = 51,
+        Indonesian = 52,
+        Interlingua = 53,
+        Interlingue = 54,
+        Inuktitut = 55,
+        Inupiak = 56,
+        Irish = 57,
+        Italian = 58,
+        Japanese = 59,
+        Javanese = 60,
+        Kannada = 61,
+        Kashmiri = 62,
+        Kazakh = 63,
+        Kinyarwanda = 64,
+        Kirghiz = 65,
+        Korean = 66,
+        Kurdish = 67,
+        Kurundi = 68,
+        Laothian = 69,
+        Latin = 70,
+        Latvian = 71,
+        Lingala = 72,
+        Lithuanian = 73,
+        Macedonian = 74,
+        Malagasy = 75,
+        Malay = 76,
+        Malayalam = 77,
+        Maltese = 78,
+        Maori = 79,
+        Marathi = 80,
+        Moldavian = 81,
+        Mongolian = 82,
+        NauruLanguage = 83,
+        Nepali = 84,
+        Norwegian = 85,
+        NorwegianBokmal = Norwegian,
+        Occitan = 86,
+        Oriya = 87,
+        Pashto = 88,
+        Persian = 89,
+        Polish = 90,
+        Portuguese = 91,
+        Punjabi = 92,
+        Quechua = 93,
+        RhaetoRomance = 94,
+        Romanian = 95,
+        Russian = 96,
+        Samoan = 97,
+        Sangho = 98,
+        Sanskrit = 99,
+        Serbian = 100,
+        SerboCroatian = 101,
+        Sesotho = 102,
+        Setswana = 103,
+        Shona = 104,
+        Sindhi = 105,
+        Singhalese = 106,
+        Siswati = 107,
+        Slovak = 108,
+        Slovenian = 109,
+        Somali = 110,
+        Spanish = 111,
+        Sundanese = 112,
+        Swahili = 113,
+        Swedish = 114,
+        Tagalog = 115,
+        Tajik = 116,
+        Tamil = 117,
+        Tatar = 118,
+        Telugu = 119,
+        Thai = 120,
+        Tibetan = 121,
+        Tigrinya = 122,
+        TongaLanguage = 123,
+        Tsonga = 124,
+        Turkish = 125,
+        Turkmen = 126,
+        Twi = 127,
+        Uigur = 128,
+        Ukrainian = 129,
+        Urdu = 130,
+        Uzbek = 131,
+        Vietnamese = 132,
+        Volapuk = 133,
+        Welsh = 134,
+        Wolof = 135,
+        Xhosa = 136,
+        Yiddish = 137,
+        Yoruba = 138,
+        Zhuang = 139,
+        Zulu = 140,
+        NorwegianNynorsk = 141,
+        Nynorsk = NorwegianNynorsk,
+        Bosnian = 142,
+        Divehi = 143,
+        Manx = 144,
+        Cornish = 145,
+        Akan = 146,
+        Konkani = 147,
+        Ga = 148,
+        Igbo = 149,
+        Kamba = 150,
+        Syriac = 151,
+        Blin = 152,
+        Geez = 153,
+        Koro = 154,
+        Sidamo = 155,
+        Atsam = 156,
+        Tigre = 157,
+        Jju = 158,
+        Friulian = 159,
+        Venda = 160,
+        Ewe = 161,
+        Walamo = 162,
+        Hawaiian = 163,
+        Tyap = 164,
+        Chewa = 165,
+        LastLanguage = Chewa
+    };
+
+    enum Country {
+        AnyCountry = 0,
+        Afghanistan = 1,
+        Albania = 2,
+        Algeria = 3,
+        AmericanSamoa = 4,
+        Andorra = 5,
+        Angola = 6,
+        Anguilla = 7,
+        Antarctica = 8,
+        AntiguaAndBarbuda = 9,
+        Argentina = 10,
+        Armenia = 11,
+        Aruba = 12,
+        Australia = 13,
+        Austria = 14,
+        Azerbaijan = 15,
+        Bahamas = 16,
+        Bahrain = 17,
+        Bangladesh = 18,
+        Barbados = 19,
+        Belarus = 20,
+        Belgium = 21,
+        Belize = 22,
+        Benin = 23,
+        Bermuda = 24,
+        Bhutan = 25,
+        Bolivia = 26,
+        BosniaAndHerzegowina = 27,
+        Botswana = 28,
+        BouvetIsland = 29,
+        Brazil = 30,
+        BritishIndianOceanTerritory = 31,
+        BruneiDarussalam = 32,
+        Bulgaria = 33,
+        BurkinaFaso = 34,
+        Burundi = 35,
+        Cambodia = 36,
+        Cameroon = 37,
+        Canada = 38,
+        CapeVerde = 39,
+        CaymanIslands = 40,
+        CentralAfricanRepublic = 41,
+        Chad = 42,
+        Chile = 43,
+        China = 44,
+        ChristmasIsland = 45,
+        CocosIslands = 46,
+        Colombia = 47,
+        Comoros = 48,
+        DemocraticRepublicOfCongo = 49,
+        PeoplesRepublicOfCongo = 50,
+        CookIslands = 51,
+        CostaRica = 52,
+        IvoryCoast = 53,
+        Croatia = 54,
+        Cuba = 55,
+        Cyprus = 56,
+        CzechRepublic = 57,
+        Denmark = 58,
+        Djibouti = 59,
+        Dominica = 60,
+        DominicanRepublic = 61,
+        EastTimor = 62,
+        Ecuador = 63,
+        Egypt = 64,
+        ElSalvador = 65,
+        EquatorialGuinea = 66,
+        Eritrea = 67,
+        Estonia = 68,
+        Ethiopia = 69,
+        FalklandIslands = 70,
+        FaroeIslands = 71,
+        FijiCountry = 72,
+        Finland = 73,
+        France = 74,
+        MetropolitanFrance = 75,
+        FrenchGuiana = 76,
+        FrenchPolynesia = 77,
+        FrenchSouthernTerritories = 78,
+        Gabon = 79,
+        Gambia = 80,
+        Georgia = 81,
+        Germany = 82,
+        Ghana = 83,
+        Gibraltar = 84,
+        Greece = 85,
+        Greenland = 86,
+        Grenada = 87,
+        Guadeloupe = 88,
+        Guam = 89,
+        Guatemala = 90,
+        Guinea = 91,
+        GuineaBissau = 92,
+        Guyana = 93,
+        Haiti = 94,
+        HeardAndMcDonaldIslands = 95,
+        Honduras = 96,
+        HongKong = 97,
+        Hungary = 98,
+        Iceland = 99,
+        India = 100,
+        Indonesia = 101,
+        Iran = 102,
+        Iraq = 103,
+        Ireland = 104,
+        Israel = 105,
+        Italy = 106,
+        Jamaica = 107,
+        Japan = 108,
+        Jordan = 109,
+        Kazakhstan = 110,
+        Kenya = 111,
+        Kiribati = 112,
+        DemocraticRepublicOfKorea = 113,
+        RepublicOfKorea = 114,
+        Kuwait = 115,
+        Kyrgyzstan = 116,
+        Lao = 117,
+        Latvia = 118,
+        Lebanon = 119,
+        Lesotho = 120,
+        Liberia = 121,
+        LibyanArabJamahiriya = 122,
+        Liechtenstein = 123,
+        Lithuania = 124,
+        Luxembourg = 125,
+        Macau = 126,
+        Macedonia = 127,
+        Madagascar = 128,
+        Malawi = 129,
+        Malaysia = 130,
+        Maldives = 131,
+        Mali = 132,
+        Malta = 133,
+        MarshallIslands = 134,
+        Martinique = 135,
+        Mauritania = 136,
+        Mauritius = 137,
+        Mayotte = 138,
+        Mexico = 139,
+        Micronesia = 140,
+        Moldova = 141,
+        Monaco = 142,
+        Mongolia = 143,
+        Montserrat = 144,
+        Morocco = 145,
+        Mozambique = 146,
+        Myanmar = 147,
+        Namibia = 148,
+        NauruCountry = 149,
+        Nepal = 150,
+        Netherlands = 151,
+        NetherlandsAntilles = 152,
+        NewCaledonia = 153,
+        NewZealand = 154,
+        Nicaragua = 155,
+        Niger = 156,
+        Nigeria = 157,
+        Niue = 158,
+        NorfolkIsland = 159,
+        NorthernMarianaIslands = 160,
+        Norway = 161,
+        Oman = 162,
+        Pakistan = 163,
+        Palau = 164,
+        PalestinianTerritory = 165,
+        Panama = 166,
+        PapuaNewGuinea = 167,
+        Paraguay = 168,
+        Peru = 169,
+        Philippines = 170,
+        Pitcairn = 171,
+        Poland = 172,
+        Portugal = 173,
+        PuertoRico = 174,
+        Qatar = 175,
+        Reunion = 176,
+        Romania = 177,
+        RussianFederation = 178,
+        Rwanda = 179,
+        SaintKittsAndNevis = 180,
+        StLucia = 181,
+        StVincentAndTheGrenadines = 182,
+        Samoa = 183,
+        SanMarino = 184,
+        SaoTomeAndPrincipe = 185,
+        SaudiArabia = 186,
+        Senegal = 187,
+        Seychelles = 188,
+        SierraLeone = 189,
+        Singapore = 190,
+        Slovakia = 191,
+        Slovenia = 192,
+        SolomonIslands = 193,
+        Somalia = 194,
+        SouthAfrica = 195,
+        SouthGeorgiaAndTheSouthSandwichIslands = 196,
+        Spain = 197,
+        SriLanka = 198,
+        StHelena = 199,
+        StPierreAndMiquelon = 200,
+        Sudan = 201,
+        Suriname = 202,
+        SvalbardAndJanMayenIslands = 203,
+        Swaziland = 204,
+        Sweden = 205,
+        Switzerland = 206,
+        SyrianArabRepublic = 207,
+        Taiwan = 208,
+        Tajikistan = 209,
+        Tanzania = 210,
+        Thailand = 211,
+        Togo = 212,
+        Tokelau = 213,
+        TongaCountry = 214,
+        TrinidadAndTobago = 215,
+        Tunisia = 216,
+        Turkey = 217,
+        Turkmenistan = 218,
+        TurksAndCaicosIslands = 219,
+        Tuvalu = 220,
+        Uganda = 221,
+        Ukraine = 222,
+        UnitedArabEmirates = 223,
+        UnitedKingdom = 224,
+        UnitedStates = 225,
+        UnitedStatesMinorOutlyingIslands = 226,
+        Uruguay = 227,
+        Uzbekistan = 228,
+        Vanuatu = 229,
+        VaticanCityState = 230,
+        Venezuela = 231,
+        VietNam = 232,
+        BritishVirginIslands = 233,
+        USVirginIslands = 234,
+        WallisAndFutunaIslands = 235,
+        WesternSahara = 236,
+        Yemen = 237,
+        Yugoslavia = 238,
+        Zambia = 239,
+        Zimbabwe = 240,
+        SerbiaAndMontenegro = 241,
+        LastCountry = SerbiaAndMontenegro
+    };
+
+    enum MeasurementSystem { MetricSystem, ImperialSystem };
+
+    enum FormatType { LongFormat, ShortFormat, NarrowFormat };
+    enum NumberOption {
+        OmitGroupSeparator = 0x01,
+        RejectGroupSeparator = 0x02
+    };
+    typedef QFlags<NumberOption> NumberOptions;
+
+    QLocale();
+    QLocale(const QString &name);
+    QLocale(Language language, Country country = AnyCountry);
+    QLocale(const QLocale &other);
+
+    QLocale &operator=(const QLocale &other);
+
+    Language language() const;
+    Country country() const;
+    QString name() const;
+
+    short toShort(const QString &s, bool *ok = 0, int base = 0) const;
+    ushort toUShort(const QString &s, bool *ok = 0, int base = 0) const;
+    int toInt(const QString &s, bool *ok = 0, int base = 0) const;
+    uint toUInt(const QString &s, bool *ok = 0, int base = 0) const;
+    qlonglong toLongLong(const QString &s, bool *ok = 0, int base = 0) const;
+    qlonglong toULongLong(const QString &s, bool *ok = 0, int base = 0) const;
+    float toFloat(const QString &s, bool *ok = 0) const;
+    double toDouble(const QString &s, bool *ok = 0) const;
+
+    QString toString(qlonglong i) const;
+    QString toString(qulonglong i) const;
+    inline QString toString(short i) const;
+    inline QString toString(ushort i) const;
+    inline QString toString(int i) const;
+    inline QString toString(uint i) const;
+    QString toString(double i, char f = 'g', int prec = 6) const;
+    inline QString toString(float i, char f = 'g', int prec = 6) const;
+    QString toString(const QDate &date, const QString &formatStr) const;
+    QString toString(const QDate &date, FormatType format = LongFormat) const;
+    QString toString(const QTime &time, const QString &formatStr) const;
+    QString toString(const QTime &time, FormatType format = LongFormat) const;
+    QString toString(const QDateTime &dateTime, FormatType format = LongFormat) const;
+    QString toString(const QDateTime &dateTime, const QString &format) const;
+
+    QString dateFormat(FormatType format = LongFormat) const;
+    QString timeFormat(FormatType format = LongFormat) const;
+    QString dateTimeFormat(FormatType format = LongFormat) const;
+
+    QDate toDate(const QString &string, FormatType = LongFormat) const;
+    QTime toTime(const QString &string, FormatType = LongFormat) const;
+    QDateTime toDateTime(const QString &string, FormatType format = LongFormat) const;
+    QDate toDate(const QString &string, const QString &format) const;
+    QTime toTime(const QString &string, const QString &format) const;
+    QDateTime toDateTime(const QString &string, const QString &format) const;
+
+
+
+
+    QChar decimalPoint() const;
+    QChar groupSeparator() const;
+    QChar percent() const;
+    QChar zeroDigit() const;
+    QChar negativeSign() const;
+    QChar positiveSign() const;
+    QChar exponential() const;
+
+    QString monthName(int, FormatType format = LongFormat) const;
+    QString standaloneMonthName(int, FormatType format = LongFormat) const;
+    QString dayName(int, FormatType format = LongFormat) const;
+    QString standaloneDayName(int, FormatType format = LongFormat) const;
+
+    QString amText() const;
+    QString pmText() const;
+
+    MeasurementSystem measurementSystem() const;
+
+    inline bool operator==(const QLocale &other) const;
+    inline bool operator!=(const QLocale &other) const;
+
+    static QString languageToString(Language language);
+    static QString countryToString(Country country);
+    static void setDefault(const QLocale &locale);
+
+    static QLocale c() { return QLocale(C); }
+    static QLocale system();
+
+    static QList<Country> countriesForLanguage(Language lang);
+
+    void setNumberOptions(NumberOptions options);
+    NumberOptions numberOptions() const;
+
+
+    struct Data {
+        quint16 index;
+        quint16 numberOptions;
+    }
+
+
+
+        ;
+private:
+    friend struct QLocalePrivate;
+
+
+    union {
+        void *v;
+        Data p;
+    };
+    const QLocalePrivate *d() const;
+};
+template <> class QTypeInfo<QLocale > { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLocale)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLocale"; } };
+inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QLocale::NumberOptions::enum_type f2) { return QFlags<QLocale::NumberOptions::enum_type>(f1) | f2; } inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QFlags<QLocale::NumberOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QLocale::NumberOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+
+inline QString QLocale::toString(short i) const
+    { return toString(qlonglong(i)); }
+inline QString QLocale::toString(ushort i) const
+    { return toString(qulonglong(i)); }
+inline QString QLocale::toString(int i) const
+    { return toString(qlonglong(i)); }
+inline QString QLocale::toString(uint i) const
+    { return toString(qulonglong(i)); }
+inline QString QLocale::toString(float i, char f, int prec) const
+    { return toString(double(i), f, prec); }
+inline bool QLocale::operator==(const QLocale &other) const
+    { return d() == other.d() && numberOptions() == other.numberOptions(); }
+inline bool QLocale::operator!=(const QLocale &other) const
+    { return d() != other.d() || numberOptions() != other.numberOptions(); }
+
+
+ QDataStream &operator<<(QDataStream &, const QLocale &);
+ QDataStream &operator>>(QDataStream &, QLocale &);
+
+
+
+
+
+# 49 "/usr/include/qt4/QtCore/qtextstream.h" 2
+# 63 "/usr/include/qt4/QtCore/qtextstream.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QTextCodec;
+class QTextDecoder;
+
+class QTextStreamPrivate;
+class QTextStream
+{
+    inline QTextStreamPrivate* d_func() { return reinterpret_cast<QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); } inline const QTextStreamPrivate* d_func() const { return reinterpret_cast<const QTextStreamPrivate *>(qGetPtrHelper(d_ptr)); } friend class QTextStreamPrivate;
+
+public:
+    enum RealNumberNotation {
+        SmartNotation,
+        FixedNotation,
+        ScientificNotation
+    };
+    enum FieldAlignment {
+        AlignLeft,
+        AlignRight,
+        AlignCenter,
+        AlignAccountingStyle
+    };
+    enum Status {
+        Ok,
+        ReadPastEnd,
+        ReadCorruptData
+    };
+    enum NumberFlag {
+        ShowBase = 0x1,
+        ForcePoint = 0x2,
+        ForceSign = 0x4,
+        UppercaseBase = 0x8,
+        UppercaseDigits = 0x10
+    };
+    typedef QFlags<NumberFlag> NumberFlags;
+
+    QTextStream();
+    explicit QTextStream(QIODevice *device);
+    explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly);
+    virtual ~QTextStream();
+
+
+    void setCodec(QTextCodec *codec);
+    void setCodec(const char *codecName);
+    QTextCodec *codec() const;
+    void setAutoDetectUnicode(bool enabled);
+    bool autoDetectUnicode() const;
+    void setGenerateByteOrderMark(bool generate);
+    bool generateByteOrderMark() const;
+
+
+    void setLocale(const QLocale &locale);
+    QLocale locale() const;
+
+    void setDevice(QIODevice *device);
+    QIODevice *device() const;
+
+    void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite);
+    QString *string() const;
+
+    Status status() const;
+    void setStatus(Status status);
+    void resetStatus();
+
+    bool atEnd() const;
+    void reset();
+    void flush();
+    bool seek(qint64 pos);
+    qint64 pos() const;
+
+    void skipWhiteSpace();
+
+    QString readLine(qint64 maxlen = 0);
+    QString readAll();
+    QString read(qint64 maxlen);
+
+    void setFieldAlignment(FieldAlignment alignment);
+    FieldAlignment fieldAlignment() const;
+
+    void setPadChar(QChar ch);
+    QChar padChar() const;
+
+    void setFieldWidth(int width);
+    int fieldWidth() const;
+
+    void setNumberFlags(NumberFlags flags);
+    NumberFlags numberFlags() const;
+
+    void setIntegerBase(int base);
+    int integerBase() const;
+
+    void setRealNumberNotation(RealNumberNotation notation);
+    RealNumberNotation realNumberNotation() const;
+
+    void setRealNumberPrecision(int precision);
+    int realNumberPrecision() const;
+
+    QTextStream &operator>>(QChar &ch);
+    QTextStream &operator>>(char &ch);
+    QTextStream &operator>>(signed short &i);
+    QTextStream &operator>>(unsigned short &i);
+    QTextStream &operator>>(signed int &i);
+    QTextStream &operator>>(unsigned int &i);
+    QTextStream &operator>>(signed long &i);
+    QTextStream &operator>>(unsigned long &i);
+    QTextStream &operator>>(qlonglong &i);
+    QTextStream &operator>>(qulonglong &i);
+    QTextStream &operator>>(float &f);
+    QTextStream &operator>>(double &f);
+    QTextStream &operator>>(QString &s);
+    QTextStream &operator>>(QByteArray &array);
+    QTextStream &operator>>(char *c);
+
+    QTextStream &operator<<(QBool b);
+    QTextStream &operator<<(QChar ch);
+    QTextStream &operator<<(char ch);
+    QTextStream &operator<<(signed short i);
+    QTextStream &operator<<(unsigned short i);
+    QTextStream &operator<<(signed int i);
+    QTextStream &operator<<(unsigned int i);
+    QTextStream &operator<<(signed long i);
+    QTextStream &operator<<(unsigned long i);
+    QTextStream &operator<<(qlonglong i);
+    QTextStream &operator<<(qulonglong i);
+    QTextStream &operator<<(float f);
+    QTextStream &operator<<(double f);
+    QTextStream &operator<<(const QString &s);
+    QTextStream &operator<<(const QByteArray &array);
+    QTextStream &operator<<(const char *c);
+    QTextStream &operator<<(const void *ptr);
+# 252 "/usr/include/qt4/QtCore/qtextstream.h"
+private:
+
+
+
+
+
+    QTextStream(const QTextStream &); QTextStream &operator=(const QTextStream &);
+
+    QScopedPointer<QTextStreamPrivate> d_ptr;
+};
+
+inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QTextStream::NumberFlags::enum_type f2) { return QFlags<QTextStream::NumberFlags::enum_type>(f1) | f2; } inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QFlags<QTextStream::NumberFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextStream::NumberFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); }
+
+
+
+
+
+typedef QTextStream & (*QTextStreamFunction)(QTextStream &);
+typedef void (QTextStream::*QTSMFI)(int);
+typedef void (QTextStream::*QTSMFC)(QChar);
+
+class QTextStreamManipulator
+{
+public:
+    QTextStreamManipulator(QTSMFI m, int a) { mf = m; mc = 0; arg = a; }
+    QTextStreamManipulator(QTSMFC m, QChar c) { mf = 0; mc = m; ch = c; arg = -1; }
+    void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } }
+
+private:
+    QTSMFI mf;
+    QTSMFC mc;
+    int arg;
+    QChar ch;
+};
+
+inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+
+inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f)
+{ return (*f)(s); }
+
+inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m)
+{ m.exec(s); return s; }
+
+ QTextStream &bin(QTextStream &s);
+ QTextStream &oct(QTextStream &s);
+ QTextStream &dec(QTextStream &s);
+ QTextStream &hex(QTextStream &s);
+
+ QTextStream &showbase(QTextStream &s);
+ QTextStream &forcesign(QTextStream &s);
+ QTextStream &forcepoint(QTextStream &s);
+ QTextStream &noshowbase(QTextStream &s);
+ QTextStream &noforcesign(QTextStream &s);
+ QTextStream &noforcepoint(QTextStream &s);
+
+ QTextStream &uppercasebase(QTextStream &s);
+ QTextStream &uppercasedigits(QTextStream &s);
+ QTextStream &lowercasebase(QTextStream &s);
+ QTextStream &lowercasedigits(QTextStream &s);
+
+ QTextStream &fixed(QTextStream &s);
+ QTextStream &scientific(QTextStream &s);
+
+ QTextStream &left(QTextStream &s);
+ QTextStream &right(QTextStream &s);
+ QTextStream &center(QTextStream &s);
+
+ QTextStream &endl(QTextStream &s);
+ QTextStream &flush(QTextStream &s);
+ QTextStream &reset(QTextStream &s);
+
+ QTextStream &bom(QTextStream &s);
+
+ QTextStream &ws(QTextStream &s);
+
+inline QTextStreamManipulator qSetFieldWidth(int width)
+{
+    QTSMFI func = &QTextStream::setFieldWidth;
+    return QTextStreamManipulator(func,width);
+}
+
+inline QTextStreamManipulator qSetPadChar(QChar ch)
+{
+    QTSMFC func = &QTextStream::setPadChar;
+    return QTextStreamManipulator(func, ch);
+}
+
+inline QTextStreamManipulator qSetRealNumberPrecision(int precision)
+{
+    QTSMFI func = &QTextStream::setRealNumberPrecision;
+    return QTextStreamManipulator(func, precision);
+}
+# 372 "/usr/include/qt4/QtCore/qtextstream.h"
+
+
+
+# 51 "/usr/include/qt4/QtCore/qdebug.h" 2
+
+
+# 1 "/usr/include/qt4/QtCore/qset.h" 1
+# 47 "/usr/include/qt4/QtCore/qset.h"
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+template <class T>
+class QSet
+{
+    typedef QHash<T, QHashDummyValue> Hash;
+
+public:
+    inline QSet() {}
+    inline QSet(const QSet<T> &other) : q_hash(other.q_hash) {}
+
+    inline QSet<T> &operator=(const QSet<T> &other)
+        { q_hash = other.q_hash; return *this; }
+
+    inline bool operator==(const QSet<T> &other) const
+        { return q_hash == other.q_hash; }
+    inline bool operator!=(const QSet<T> &other) const
+        { return q_hash != other.q_hash; }
+
+    inline int size() const { return q_hash.size(); }
+
+    inline bool isEmpty() const { return q_hash.isEmpty(); }
+
+    inline int capacity() const { return q_hash.capacity(); }
+    inline void reserve(int size);
+    inline void squeeze() { q_hash.squeeze(); }
+
+    inline void detach() { q_hash.detach(); }
+    inline bool isDetached() const { return q_hash.isDetached(); }
+    inline void setSharable(bool sharable) { q_hash.setSharable(sharable); }
+
+    inline void clear() { q_hash.clear(); }
+
+    inline bool remove(const T &value) { return q_hash.remove(value) != 0; }
+
+    inline bool contains(const T &value) const { return q_hash.contains(value); }
+
+    bool contains(const QSet<T> &set) const;
+
+    class const_iterator;
+
+    class iterator
+    {
+        typedef QHash<T, QHashDummyValue> Hash;
+        typename Hash::iterator i;
+        friend class const_iterator;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+
+        inline iterator() {}
+        inline iterator(typename Hash::iterator o) : i(o) {}
+        inline iterator(const iterator &o) : i(o.i) {}
+        inline iterator &operator=(const iterator &o) { i = o.i; return *this; }
+        inline const T &operator*() const { return i.key(); }
+        inline const T *operator->() const { return &i.key(); }
+        inline bool operator==(const iterator &o) const { return i == o.i; }
+        inline bool operator!=(const iterator &o) const { return i != o.i; }
+        inline bool operator==(const const_iterator &o) const
+            { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const
+            { return i != o.i; }
+        inline iterator &operator++() { ++i; return *this; }
+        inline iterator operator++(int) { iterator r = *this; ++i; return r; }
+        inline iterator &operator--() { --i; return *this; }
+        inline iterator operator--(int) { iterator r = *this; --i; return r; }
+        inline iterator operator+(int j) const { return i + j; }
+        inline iterator operator-(int j) const { return i - j; }
+        inline iterator &operator+=(int j) { i += j; return *this; }
+        inline iterator &operator-=(int j) { i -= j; return *this; }
+    };
+
+    class const_iterator
+    {
+        typedef QHash<T, QHashDummyValue> Hash;
+        typename Hash::const_iterator i;
+        friend class iterator;
+
+    public:
+        typedef std::bidirectional_iterator_tag iterator_category;
+        typedef ptrdiff_t difference_type;
+        typedef T value_type;
+        typedef const T *pointer;
+        typedef const T &reference;
+
+        inline const_iterator() {}
+        inline const_iterator(typename Hash::const_iterator o) : i(o) {}
+        inline const_iterator(const const_iterator &o) : i(o.i) {}
+        inline const_iterator(const iterator &o)
+            : i(o.i) {}
+        inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; }
+        inline const T &operator*() const { return i.key(); }
+        inline const T *operator->() const { return &i.key(); }
+        inline bool operator==(const const_iterator &o) const { return i == o.i; }
+        inline bool operator!=(const const_iterator &o) const { return i != o.i; }
+        inline const_iterator &operator++() { ++i; return *this; }
+        inline const_iterator operator++(int) { const_iterator r = *this; ++i; return r; }
+        inline const_iterator &operator--() { --i; return *this; }
+        inline const_iterator operator--(int) { const_iterator r = *this; --i; return r; }
+        inline const_iterator operator+(int j) const { return i + j; }
+        inline const_iterator operator-(int j) const { return i - j; }
+        inline const_iterator &operator+=(int j) { i += j; return *this; }
+        inline const_iterator &operator-=(int j) { i -= j; return *this; }
+    };
+
+
+    inline iterator begin() { return q_hash.begin(); }
+    inline const_iterator begin() const { return q_hash.begin(); }
+    inline const_iterator constBegin() const { return q_hash.constBegin(); }
+    inline iterator end() { return q_hash.end(); }
+    inline const_iterator end() const { return q_hash.end(); }
+    inline const_iterator constEnd() const { return q_hash.constEnd(); }
+    iterator erase(iterator i)
+        { return q_hash.erase(reinterpret_cast<typename Hash::iterator &>(i)); }
+
+
+    typedef iterator Iterator;
+    typedef const_iterator ConstIterator;
+    inline int count() const { return q_hash.count(); }
+    inline const_iterator insert(const T &value)
+        { return static_cast<typename Hash::const_iterator>(q_hash.insert(value,
+                                                                          QHashDummyValue())); }
+    iterator find(const T &value) { return q_hash.find(value); }
+    const_iterator find(const T &value) const { return q_hash.find(value); }
+    inline const_iterator constFind(const T &value) const { return find(value); }
+    QSet<T> &unite(const QSet<T> &other);
+    QSet<T> &intersect(const QSet<T> &other);
+    QSet<T> &subtract(const QSet<T> &other);
+
+
+    typedef T key_type;
+    typedef T value_type;
+    typedef value_type *pointer;
+    typedef const value_type *const_pointer;
+    typedef value_type &reference;
+    typedef const value_type &const_reference;
+    typedef ptrdiff_t difference_type;
+    typedef int size_type;
+
+    inline bool empty() const { return isEmpty(); }
+
+
+    inline QSet<T> &operator<<(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator|=(const QSet<T> &other) { unite(other); return *this; }
+    inline QSet<T> &operator|=(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator&=(const QSet<T> &other) { intersect(other); return *this; }
+    inline QSet<T> &operator&=(const T &value)
+        { QSet<T> result; if (contains(value)) result.insert(value); return (*this = result); }
+    inline QSet<T> &operator+=(const QSet<T> &other) { unite(other); return *this; }
+    inline QSet<T> &operator+=(const T &value) { insert(value); return *this; }
+    inline QSet<T> &operator-=(const QSet<T> &other) { subtract(other); return *this; }
+    inline QSet<T> &operator-=(const T &value) { remove(value); return *this; }
+    inline QSet<T> operator|(const QSet<T> &other) const
+        { QSet<T> result = *this; result |= other; return result; }
+    inline QSet<T> operator&(const QSet<T> &other) const
+        { QSet<T> result = *this; result &= other; return result; }
+    inline QSet<T> operator+(const QSet<T> &other) const
+        { QSet<T> result = *this; result += other; return result; }
+    inline QSet<T> operator-(const QSet<T> &other) const
+        { QSet<T> result = *this; result -= other; return result; }
+
+
+    inline QSet<T> operator|(const QSet<T> &other)
+        { QSet<T> result = *this; result |= other; return result; }
+    inline QSet<T> operator&(const QSet<T> &other)
+        { QSet<T> result = *this; result &= other; return result; }
+    inline QSet<T> operator+(const QSet<T> &other)
+        { QSet<T> result = *this; result += other; return result; }
+    inline QSet<T> operator-(const QSet<T> &other)
+        { QSet<T> result = *this; result -= other; return result; }
+
+
+    QList<T> toList() const;
+    inline QList<T> values() const { return toList(); }
+
+    static QSet<T> fromList(const QList<T> &list);
+
+private:
+    Hash q_hash;
+};
+
+template <class T>
+inline void QSet<T>::reserve(int asize) { q_hash.reserve(asize); }
+
+template <class T>
+inline QSet<T> &QSet<T>::unite(const QSet<T> &other)
+{
+    QSet<T> copy(other);
+    typename QSet<T>::const_iterator i = copy.constEnd();
+    while (i != copy.constBegin()) {
+        --i;
+        insert(*i);
+    }
+    return *this;
+}
+
+template <class T>
+inline QSet<T> &QSet<T>::intersect(const QSet<T> &other)
+{
+    QSet<T> copy1(*this);
+    QSet<T> copy2(other);
+    typename QSet<T>::const_iterator i = copy1.constEnd();
+    while (i != copy1.constBegin()) {
+        --i;
+        if (!copy2.contains(*i))
+            remove(*i);
+    }
+    return *this;
+}
+
+template <class T>
+inline QSet<T> &QSet<T>::subtract(const QSet<T> &other)
+{
+    QSet<T> copy1(*this);
+    QSet<T> copy2(other);
+    typename QSet<T>::const_iterator i = copy1.constEnd();
+    while (i != copy1.constBegin()) {
+        --i;
+        if (copy2.contains(*i))
+            remove(*i);
+    }
+    return *this;
+}
+
+template <class T>
+inline bool QSet<T>::contains(const QSet<T> &other) const
+{
+    typename QSet<T>::const_iterator i = other.constBegin();
+    while (i != other.constEnd()) {
+        if (!contains(*i))
+            return false;
+        ++i;
+    }
+    return true;
+}
+
+template <typename T>
+ QList<T> QSet<T>::toList() const
+{
+    QList<T> result;
+    typename QSet<T>::const_iterator i = constBegin();
+    while (i != constEnd()) {
+        result.append(*i);
+        ++i;
+    }
+    return result;
+}
+
+template <typename T>
+ QSet<T> QList<T>::toSet() const
+{
+    QSet<T> result;
+    result.reserve(size());
+    for (int i = 0; i < size(); ++i)
+        result.insert(at(i));
+    return result;
+}
+
+template <typename T>
+QSet<T> QSet<T>::fromList(const QList<T> &list)
+{
+    return list.toSet();
+}
+
+template <typename T>
+QList<T> QList<T>::fromSet(const QSet<T> &set)
+{
+    return set.toList();
+}
+
+template <class T> class QSetIterator { typedef typename QSet<T>::const_iterator const_iterator; QSet<T> c; const_iterator i; public: inline QSetIterator(const QSet<T> &container) : c(container), i(c.constBegin()) {} inline QSetIterator &operator=(const QSet<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } };
+
+template <typename T>
+class QMutableSetIterator
+{
+    typedef typename QSet<T>::iterator iterator;
+    QSet<T> *c;
+    iterator i, n;
+    inline bool item_exists() const { return n != c->constEnd(); }
+
+public:
+    inline QMutableSetIterator(QSet<T> &container)
+        : c(&container)
+    { c->setSharable(false); i = c->begin(); n = c->end(); }
+    inline ~QMutableSetIterator()
+    { c->setSharable(true); }
+    inline QMutableSetIterator &operator=(QSet<T> &container)
+    { c->setSharable(true); c = &container; c->setSharable(false);
+      i = c->begin(); n = c->end(); return *this; }
+    inline void toFront() { i = c->begin(); n = c->end(); }
+    inline void toBack() { i = c->end(); n = i; }
+    inline bool hasNext() const { return c->constEnd() != i; }
+    inline const T &next() { n = i++; return *n; }
+    inline const T &peekNext() const { return *i; }
+    inline bool hasPrevious() const { return c->constBegin() != i; }
+    inline const T &previous() { n = --i; return *n; }
+    inline const T &peekPrevious() const { iterator p = i; return *--p; }
+    inline void remove()
+    { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } }
+    inline const T &value() const { ((!(item_exists())) ? qt_assert("item_exists()","/usr/include/qt4/QtCore/qset.h",354) : qt_noop()); return *n; }
+    inline bool findNext(const T &t)
+    { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; }
+    inline bool findPrevious(const T &t)
+    { while (c->constBegin() != i) if (*(n = --i) == t) return true;
+      n = c->end(); return false; }
+};
+
+
+
+
+# 54 "/usr/include/qt4/QtCore/qdebug.h" 2
+# 1 "/usr/include/qt4/QtCore/qcontiguouscache.h" 1
+# 46 "/usr/include/qt4/QtCore/qcontiguouscache.h"
+# 1 "/usr/lib/gcc/x86_64-pc-linux-gnu/4.5.0/include-fixed/limits.h" 1 3 4
+# 47 "/usr/include/qt4/QtCore/qcontiguouscache.h" 2
+
+
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+
+struct QContiguousCacheData
+{
+    QBasicAtomicInt ref;
+    int alloc;
+    int count;
+    int start;
+    int offset;
+    uint sharable : 1;
+    uint reserved : 31;
+
+
+
+
+
+
+    static QContiguousCacheData *allocate(int size, int alignment);
+    static void free(QContiguousCacheData *data);
+
+
+
+
+};
+
+template <typename T>
+struct QContiguousCacheTypedData: private QContiguousCacheData
+{
+
+    T array[1];
+
+    static inline void free(QContiguousCacheTypedData *data) { QContiguousCacheData::free(data); }
+};
+
+template<typename T>
+class QContiguousCache {
+    typedef QContiguousCacheTypedData<T> Data;
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; };
+public:
+
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef ptrdiff_t difference_type;
+    typedef int size_type;
+
+    explicit QContiguousCache(int capacity = 0);
+    QContiguousCache(const QContiguousCache<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
+
+    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) free(p); }
+
+    inline void detach() { if (d->ref != 1) detach_helper(); }
+    inline bool isDetached() const { return d->ref == 1; }
+    inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; }
+
+    QContiguousCache<T> &operator=(const QContiguousCache<T> &other);
+    bool operator==(const QContiguousCache<T> &other) const;
+    inline bool operator!=(const QContiguousCache<T> &other) const { return !(*this == other); }
+
+    inline int capacity() const {return d->alloc; }
+    inline int count() const { return d->count; }
+    inline int size() const { return d->count; }
+
+    inline bool isEmpty() const { return d->count == 0; }
+    inline bool isFull() const { return d->count == d->alloc; }
+    inline int available() const { return d->alloc - d->count; }
+
+    void clear();
+    void setCapacity(int size);
+
+    const T &at(int pos) const;
+    T &operator[](int i);
+    const T &operator[](int i) const;
+
+    void append(const T &value);
+    void prepend(const T &value);
+    void insert(int pos, const T &value);
+
+    inline bool containsIndex(int pos) const { return pos >= d->offset && pos - d->offset < d->count; }
+    inline int firstIndex() const { return d->offset; }
+    inline int lastIndex() const { return d->offset + d->count - 1; }
+
+    inline const T &first() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",139) : qt_noop()); return p->array[d->start]; }
+    inline const T &last() const { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",140) : qt_noop()); return p->array[(d->start + d->count -1) % d->alloc]; }
+    inline T &first() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",141) : qt_noop()); detach(); return p->array[d->start]; }
+    inline T &last() { ((!(!isEmpty())) ? qt_assert("!isEmpty()","/usr/include/qt4/QtCore/qcontiguouscache.h",142) : qt_noop()); detach(); return p->array[(d->start + d->count -1) % d->alloc]; }
+
+    void removeFirst();
+    T takeFirst();
+    void removeLast();
+    T takeLast();
+
+    inline bool areIndexesValid() const
+    { return d->offset >= 0 && d->offset < 2147483647 - d->count && (d->offset % d->alloc) == d->start; }
+
+    inline void normalizeIndexes() { d->offset = d->start; }
+
+
+
+
+private:
+    void detach_helper();
+
+    QContiguousCacheData *malloc(int aalloc);
+    void free(Data *x);
+    int sizeOfTypedData() {
+
+
+        return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
+    }
+    int alignOfTypedData() const
+    {
+
+        return qMax<int>(sizeof(void*), __alignof__(Data));
+
+
+
+    }
+};
+
+template <typename T>
+void QContiguousCache<T>::detach_helper()
+{
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+
+    x.d = malloc(d->alloc);
+    x.d->ref = 1;
+    x.d->count = d->count;
+    x.d->start = d->start;
+    x.d->offset = d->offset;
+    x.d->alloc = d->alloc;
+    x.d->sharable = true;
+    x.d->reserved = 0;
+
+    T *dest = x.p->array + x.d->start;
+    T *src = p->array + d->start;
+    int oldcount = x.d->count;
+    while (oldcount--) {
+        if (QTypeInfo<T>::isComplex) {
+            new (dest) T(*src);
+        } else {
+            *dest = *src;
+        }
+        dest++;
+        if (dest == x.p->array + x.d->alloc)
+            dest = x.p->array;
+        src++;
+        if (src == p->array + d->alloc)
+            src = p->array;
+    }
+
+    if (!d->ref.deref())
+        free(p);
+    d = x.d;
+}
+
+template <typename T>
+void QContiguousCache<T>::setCapacity(int asize)
+{
+    if (asize == d->alloc)
+        return;
+    detach();
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+    x.d = malloc(asize);
+    x.d->alloc = asize;
+    x.d->count = qMin(d->count, asize);
+    x.d->offset = d->offset + d->count - x.d->count;
+    x.d->start = x.d->offset % x.d->alloc;
+    T *dest = x.p->array + (x.d->start + x.d->count-1) % x.d->alloc;
+    T *src = p->array + (d->start + d->count-1) % d->alloc;
+    int oldcount = x.d->count;
+    while (oldcount--) {
+        if (QTypeInfo<T>::isComplex) {
+            new (dest) T(*src);
+        } else {
+            *dest = *src;
+        }
+        if (dest == x.p->array)
+            dest = x.p->array + x.d->alloc;
+        dest--;
+        if (src == p->array)
+            src = p->array + d->alloc;
+        src--;
+    }
+
+    free(p);
+    d = x.d;
+}
+
+template <typename T>
+void QContiguousCache<T>::clear()
+{
+    if (d->ref == 1) {
+        if (QTypeInfo<T>::isComplex) {
+            int oldcount = d->count;
+            T * i = p->array + d->start;
+            T * e = p->array + d->alloc;
+            while (oldcount--) {
+                i->~T();
+                i++;
+                if (i == e)
+                    i = p->array;
+            }
+        }
+        d->count = d->start = d->offset = 0;
+    } else {
+        union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+        x.d = malloc(d->alloc);
+        x.d->ref = 1;
+        x.d->alloc = d->alloc;
+        x.d->count = x.d->start = x.d->offset = 0;
+        x.d->sharable = true;
+        if (!d->ref.deref()) free(p);
+        d = x.d;
+    }
+}
+
+template <typename T>
+inline QContiguousCacheData *QContiguousCache<T>::malloc(int aalloc)
+{
+    return QContiguousCacheData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
+}
+
+template <typename T>
+QContiguousCache<T>::QContiguousCache(int cap)
+{
+    d = malloc(cap);
+    d->ref = 1;
+    d->alloc = cap;
+    d->count = d->start = d->offset = 0;
+    d->sharable = true;
+}
+
+template <typename T>
+QContiguousCache<T> &QContiguousCache<T>::operator=(const QContiguousCache<T> &other)
+{
+    other.d->ref.ref();
+    if (!d->ref.deref())
+        free(d);
+    d = other.d;
+    if (!d->sharable)
+        detach_helper();
+    return *this;
+}
+
+template <typename T>
+bool QContiguousCache<T>::operator==(const QContiguousCache<T> &other) const
+{
+    if (other.d == d)
+        return true;
+    if (other.d->start != d->start
+            || other.d->count != d->count
+            || other.d->offset != d->offset
+            || other.d->alloc != d->alloc)
+        return false;
+    for (int i = firstIndex(); i <= lastIndex(); ++i)
+        if (!(at(i) == other.at(i)))
+            return false;
+    return true;
+}
+
+template <typename T>
+void QContiguousCache<T>::free(Data *x)
+{
+    if (QTypeInfo<T>::isComplex) {
+        int oldcount = d->count;
+        T * i = p->array + d->start;
+        T * e = p->array + d->alloc;
+        while (oldcount--) {
+            i->~T();
+            i++;
+            if (i == e)
+                i = p->array;
+        }
+    }
+    x->free(x);
+}
+template <typename T>
+void QContiguousCache<T>::append(const T &value)
+{
+    detach();
+    if (QTypeInfo<T>::isComplex) {
+        if (d->count == d->alloc)
+            (p->array + (d->start+d->count) % d->alloc)->~T();
+        new (p->array + (d->start+d->count) % d->alloc) T(value);
+    } else {
+        p->array[(d->start+d->count) % d->alloc] = value;
+    }
+
+    if (d->count == d->alloc) {
+        d->start++;
+        d->start %= d->alloc;
+        d->offset++;
+    } else {
+        d->count++;
+    }
+}
+
+template<typename T>
+void QContiguousCache<T>::prepend(const T &value)
+{
+    detach();
+    if (d->start)
+        d->start--;
+    else
+        d->start = d->alloc-1;
+    d->offset--;
+
+    if (d->count != d->alloc)
+        d->count++;
+    else
+        if (d->count == d->alloc)
+            (p->array + d->start)->~T();
+
+    if (QTypeInfo<T>::isComplex)
+        new (p->array + d->start) T(value);
+    else
+        p->array[d->start] = value;
+}
+
+template<typename T>
+void QContiguousCache<T>::insert(int pos, const T &value)
+{
+    ((!(pos >= 0 && pos < 2147483647)) ? qt_assert_x("QContiguousCache<T>::insert", "index out of range","/usr/include/qt4/QtCore/qcontiguouscache.h",380) : qt_noop());
+    detach();
+    if (containsIndex(pos)) {
+        if(QTypeInfo<T>::isComplex)
+            new (p->array + pos % d->alloc) T(value);
+        else
+            p->array[pos % d->alloc] = value;
+    } else if (pos == d->offset-1)
+        prepend(value);
+    else if (pos == d->offset+d->count)
+        append(value);
+    else {
+
+        clear();
+        d->offset = pos;
+        d->start = pos % d->alloc;
+        d->count = 1;
+        if (QTypeInfo<T>::isComplex)
+            new (p->array + d->start) T(value);
+        else
+            p->array[d->start] = value;
+    }
+}
+
+template <typename T>
+inline const T &QContiguousCache<T>::at(int pos) const
+{ ((!(pos >= d->offset && pos - d->offset < d->count)) ? qt_assert_x("QContiguousCache<T>::at", "index out of range","/usr/include/qt4/QtCore/qcontiguouscache.h",406) : qt_noop()); return p->array[pos % d->alloc]; }
+template <typename T>
+inline const T &QContiguousCache<T>::operator[](int pos) const
+{ ((!(pos >= d->offset && pos - d->offset < d->count)) ? qt_assert_x("QContiguousCache<T>::at", "index out of range","/usr/include/qt4/QtCore/qcontiguouscache.h",409) : qt_noop()); return p->array[pos % d->alloc]; }
+
+template <typename T>
+inline T &QContiguousCache<T>::operator[](int pos)
+{
+    detach();
+    if (!containsIndex(pos))
+        insert(pos, T());
+    return p->array[pos % d->alloc];
+}
+
+template <typename T>
+inline void QContiguousCache<T>::removeFirst()
+{
+    ((!(d->count > 0)) ? qt_assert("d->count > 0","/usr/include/qt4/QtCore/qcontiguouscache.h",423) : qt_noop());
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (p->array + d->start)->~T();
+    d->start = (d->start + 1) % d->alloc;
+    d->offset++;
+}
+
+template <typename T>
+inline void QContiguousCache<T>::removeLast()
+{
+    ((!(d->count > 0)) ? qt_assert("d->count > 0","/usr/include/qt4/QtCore/qcontiguouscache.h",435) : qt_noop());
+    detach();
+    d->count--;
+    if (QTypeInfo<T>::isComplex)
+        (p->array + (d->start + d->count) % d->alloc)->~T();
+}
+
+template <typename T>
+inline T QContiguousCache<T>::takeFirst()
+{ T t = first(); removeFirst(); return t; }
+
+template <typename T>
+inline T QContiguousCache<T>::takeLast()
+{ T t = last(); removeLast(); return t; }
+
+
+
+
+# 55 "/usr/include/qt4/QtCore/qdebug.h" 2
+
+
+
+
+
+typedef QtValidLicenseForCoreModule QtCoreModule;
+
+class QDebug
+{
+    struct Stream {
+        Stream(QIODevice *device) : ts(device), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
+        Stream(QString *string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg), space(true), message_output(false) {}
+        Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t), space(true), message_output(true) {}
+        QTextStream ts;
+        QString buffer;
+        int ref;
+        QtMsgType type;
+        bool space;
+        bool message_output;
+    } *stream;
+public:
+    inline QDebug(QIODevice *device) : stream(new Stream(device)) {}
+    inline QDebug(QString *string) : stream(new Stream(string)) {}
+    inline QDebug(QtMsgType t) : stream(new Stream(t)) {}
+    inline QDebug(const QDebug &o):stream(o.stream) { ++stream->ref; }
+    inline QDebug &operator=(const QDebug &other);
+    inline ~QDebug() {
+        if (!--stream->ref) {
+            if(stream->message_output) {
+                try {
+                    qt_message_output(stream->type, stream->buffer.toLocal8Bit().data());
+                } catch (std::bad_alloc&) { }
+            }
+            delete stream;
+        }
+    }
+    inline QDebug &space() { stream->space = true; stream->ts << ' '; return *this; }
+    inline QDebug &nospace() { stream->space = false; return *this; }
+    inline QDebug &maybeSpace() { if (stream->space) stream->ts << ' '; return *this; }
+
+    inline QDebug &operator<<(QChar t) { stream->ts << '\'' << t << '\''; return maybeSpace(); }
+    inline QDebug &operator<<(QBool t) { stream->ts << (bool(t != 0) ? "true" : "false"); return maybeSpace(); }
+    inline QDebug &operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); }
+    inline QDebug &operator<<(char t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed short t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(signed long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(qint64 t)
+        { stream->ts << QString::number(t); return maybeSpace(); }
+    inline QDebug &operator<<(quint64 t)
+        { stream->ts << QString::number(t); return maybeSpace(); }
+    inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(const char* t) { stream->ts << QString::fromAscii(t); return maybeSpace(); }
+    inline QDebug &operator<<(const QString & t) { stream->ts << '\"' << t << '\"'; return maybeSpace(); }
+    inline QDebug &operator<<(const QStringRef & t) { return operator<<(t.toString()); }
+    inline QDebug &operator<<(const QLatin1String &t) { stream->ts << '\"' << t.latin1() << '\"'; return maybeSpace(); }
+    inline QDebug &operator<<(const QByteArray & t) { stream->ts << '\"' << t << '\"'; return maybeSpace(); }
+    inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); }
+    inline QDebug &operator<<(QTextStreamFunction f) {
+        stream->ts << f;
+        return *this;
+    }
+
+    inline QDebug &operator<<(QTextStreamManipulator m)
+    { stream->ts << m; return *this; }
+};
+
+class QNoDebug
+{
+public:
+    inline QNoDebug(){}
+    inline QNoDebug(const QDebug &){}
+    inline ~QNoDebug(){}
+
+    inline QNoDebug &operator<<(QTextStreamFunction) { return *this; }
+    inline QNoDebug &operator<<(QTextStreamManipulator) { return *this; }
+
+    inline QNoDebug &space() { return *this; }
+    inline QNoDebug &nospace() { return *this; }
+    inline QNoDebug &maybeSpace() { return *this; }
+
+
+    template<typename T>
+    inline QNoDebug &operator<<(const T &) { return *this; }
+
+};
+
+ inline QDebug qCritical() { return QDebug(QtCriticalMsg); }
+
+inline QDebug &QDebug::operator=(const QDebug &other)
+{
+    if (this != &other) {
+        QDebug copy(other);
+        qSwap(stream, copy.stream);
+    }
+    return *this;
+}
+
+
+
+
+
+template <class T>
+inline QDebug operator<<(QDebug debug, const QList<T> &list)
+
+{
+    debug.nospace() << '(';
+    for (typename QList<T>::size_type i = 0; i < list.count(); ++i) {
+        if (i)
+            debug << ", ";
+        debug << list.at(i);
+    }
+    debug << ')';
+    return debug.space();
+}
+
+
+
+
+
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QVector<T> &vec)
+
+{
+    debug.nospace() << "QVector";
+    return operator<<(debug, vec.toList());
+}
+
+
+
+
+
+template <class aKey, class aT>
+inline QDebug operator<<(QDebug debug, const QMap<aKey, aT> &map)
+
+{
+    debug.nospace() << "QMap(";
+    for (typename QMap<aKey, aT>::const_iterator it = map.constBegin();
+         it != map.constEnd(); ++it) {
+        debug << '(' << it.key() << ", " << it.value() << ')';
+    }
+    debug << ')';
+    return debug.space();
+}
+
+
+
+
+
+template <class aKey, class aT>
+inline QDebug operator<<(QDebug debug, const QHash<aKey, aT> &hash)
+
+{
+    debug.nospace() << "QHash(";
+    for (typename QHash<aKey, aT>::const_iterator it = hash.constBegin();
+            it != hash.constEnd(); ++it)
+        debug << '(' << it.key() << ", " << it.value() << ')';
+    debug << ')';
+    return debug.space();
+}
+
+
+
+
+
+template <class T1, class T2>
+inline QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair)
+
+{
+    debug.nospace() << "QPair(" << pair.first << ',' << pair.second << ')';
+    return debug.space();
+}
+
+template <typename T>
+inline QDebug operator<<(QDebug debug, const QSet<T> &set)
+{
+    debug.nospace() << "QSet";
+    return operator<<(debug, set.toList());
+}
+
+
+
+
+
+template <class T>
+inline QDebug operator<<(QDebug debug, const QContiguousCache<T> &cache)
+
+{
+    debug.nospace() << "QContiguousCache(";
+    for (int i = cache.firstIndex(); i <= cache.lastIndex(); ++i) {
+        debug << cache[i];
+        if (i != cache.lastIndex())
+            debug << ", ";
+    }
+    debug << ')';
+    return debug.space();
+}
+
+
+ inline QDebug qDebug() { return QDebug(QtDebugMsg); }
+# 273 "/usr/include/qt4/QtCore/qdebug.h"
+ inline QDebug qWarning() { return QDebug(QtWarningMsg); }
+
+
+
+
+
+
+
+
+
+# 1 "/usr/include/qt4/QtCore/QDebug" 2
+# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qptr.hpp" 2
+
+
+namespace PySide
+{
+
+
+
+
+class __attribute__ ((visibility("default"))) qptr_base
+{
+public:
+    enum construction_mode {
+        none = 0x00000000,
+        check_cache = 0x00000001,
+        no_check_cache = 0x00000002,
+        wrapper_pointer = 0x00000004,
+        no_wrapper_pointer = 0x00000008
+    };
+
+    qptr_base(void* cpp_obj, PyObject *py_obj, void (*deleter)(void*), int mode);
+    qptr_base(const qptr_base& other);
+    qptr_base() : m_data(0) {}
+    virtual ~qptr_base();
+
+
+
+
+
+
+    static void invalidate(void *cpp_obj, bool cleanup = false);
+    static bool exists(void *cpp_obj);
+
+    bool is_null() const;
+
+    qptr_base& operator=(const qptr_base& other);
+
+    bool
+    operator==(const qptr_base& other)
+    {
+        return m_data == other.m_data;
+    }
+
+
+    void acquire_ownership();
+    void release_ownership();
+    bool has_ownership();
+
+
+    bool is_wrapper() const;
+    void add_cpp_ref();
+    void remove_cpp_ref();
+    bool has_cpp_ref();
+
+    void add_child(qptr_base &child);
+    void remove_child(qptr_base &child);
+    void remove_parent();
+
+    PyObject* get_pyobject();
+    void set_pyobject(PyObject *py_obj);
+
+    void release();
+
+
+    bool has_parent();
+    int children_count();
+    int refcount();
+    static inline int list_size() { return m_cpp_to_qptrs.size(); }
+
+    void* raw_ptr() const;
+
+protected:
+    bool ptr_assert() const;
+    void destroy();
+    void invalidate();
+    void invalidate(bool invalidate_ptr);
+
+    class qptr_base_private;
+    mutable qptr_base_private* m_data;
+    static QHash<const volatile void*, qptr_base_private*> m_cpp_to_qptrs;
+    explicit qptr_base(qptr_base::qptr_base_private* data);
+    qptr_base_private* create_copy() const;
+};
+
+
+template<typename T>
+inline __attribute__ ((visibility("internal")))
+void delete_pointer(T *p)
+{
+    delete p;
+}
+
+template<typename T>
+inline __attribute__ ((visibility("internal")))
+void delete_pointer_helper(void* p)
+{
+    T *ptr = reinterpret_cast<T*>(p);
+    delete_pointer(ptr);
+}
+
+
+
+
+template<class T,
+         int c_mode = (int) qptr_base::check_cache>
+class __attribute__ ((visibility("internal"))) qptr : public qptr_base
+{
+public:
+    typedef T element_type;
+    typedef T value_type;
+    typedef T * pointer;
+
+public:
+    qptr(T* ptr, int mode = c_mode)
+        : qptr_base(get_void_pointer(ptr),
+                    (mode & wrapper_pointer ? extract_pyobject(ptr, boost::is_polymorphic<T>()) : 0 ),
+                    &delete_pointer_helper<T>, mode)
+    {
+    }
+
+    template<typename Y>
+    qptr(const qptr<Y>& ptr) : qptr_base(ptr)
+    {
+    }
+
+    qptr(T* ptr, PyObject* py_obj)
+        : qptr_base(get_void_pointer(ptr), py_obj, &delete_pointer_helper<T>, no_check_cache | no_wrapper_pointer)
+    {
+    }
+
+    qptr(PyObject* py_obj)
+        : qptr_base(get_void_pointer(boost::python::extract<T*>(py_obj)), py_obj,
+                    &delete_pointer_helper<T>, c_mode)
+    {
+    }
+
+    template<typename Y>
+    qptr&
+    operator=(const qptr<Y>& ptr)
+    {
+        if ( m_data != ptr.m_data ) {
+            release();
+            m_data = ptr.create_copy();
+        }
+        return *this;
+    }
+
+    inline T&
+    operator*() const
+    {
+        return *get();
+    }
+
+    inline T*
+    operator->() const
+    {
+        return get();
+    }
+
+    inline T*
+    get() const
+    {
+        ptr_assert();
+        return reinterpret_cast<T*>(raw_ptr());
+    }
+
+    ~qptr()
+    {
+        if (!is_null() && refcount() == 1 && has_cpp_ref()) {
+            notify_ptr_del(reinterpret_cast<T*>(raw_ptr()), boost::is_polymorphic<T>());
+        }
+    }
+
+    static inline void* get_void_pointer(T* pointer)
+    {
+        return get_void_pointer(pointer, boost::is_polymorphic<T>());
+    }
+
+private:
+    static inline PyObject*
+    extract_pyobject(T* ptr, boost::mpl::false_)
+    {
+        return 0;
+    }
+
+    static inline PyObject*
+    extract_pyobject(T* ptr, boost::mpl::true_)
+    {
+        PySide::wrapper *w = dynamic_cast<PySide::wrapper*>(ptr);
+        if (w)
+            return w->py_object();
+        else
+            return 0;
+    }
+
+    static inline void
+    notify_ptr_del(T* ptr, boost::mpl::false_)
+    {
+    }
+
+    static inline void
+    notify_ptr_del(T* ptr, boost::mpl::true_)
+    {
+        PySide::wrapper *w = dynamic_cast<PySide::wrapper*>(ptr);
+        if (w)
+            w->keep_cpp_ref();
+    }
+
+    static inline void*
+    get_void_pointer(T* ptr, boost::mpl::false_)
+    {
+        return static_cast<void*>(ptr);
+    }
+
+    static inline void*
+    get_void_pointer(T* ptr, boost::mpl::true_)
+    {
+        boost::python::objects::dynamic_id_t base_id =
+            boost::python::objects::polymorphic_id_generator<T>::execute(ptr);
+        return base_id.first;
+    }
+
+};
+
+
+
+
+template<class T, int mode>
+inline __attribute__ ((visibility("internal"))) T*
+get_pointer(qptr<T, mode> const& p){
+    return p.get();
+}
+
+}
+# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 2
+
+namespace PySide
+{
+
+
+
+
+
+
+
+template <
+    class T
+    , class BasePolicy_ = boost::python::default_call_policies>
+struct __attribute__ ((visibility("internal"))) register_wrapper_object : BasePolicy_
+{
+    template <class ArgumentPackage>
+    static PyObject*
+    postcall(ArgumentPackage const& args_, PyObject* result)
+    {
+        result = BasePolicy_::postcall(args_, result);
+        if (result) {
+
+            PyObject* py_self =
+                    boost::python::detail::get_prev<1>::execute(args_, result);
+            qptr<T> ptr_parent(py_self);
+        }
+        return result;
+    }
+};
+# 72 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
+template <
+    std::size_t parent
+  , std::size_t child
+  , class T_PARENT
+  , class T_CHILD
+  , class BasePolicy_ = boost::python::default_call_policies
+  , class T = void>
+struct __attribute__ ((visibility("internal"))) parent_policy_add : BasePolicy_
+{
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((parent != child) == 0 ? false : true) >)> boost_static_assert_typedef_81;
+
+    template <class ArgumentPackage>
+    static PyObject*
+    postcall(ArgumentPackage const& args_, PyObject* result)
+    {
+        unsigned arity_ = boost::python::detail::arity(args_);
+        if ((std::max)(parent, child) > arity_) {
+
+
+            return BasePolicy_::postcall(args_, result);
+        }
+
+        result = BasePolicy_::postcall(args_, result);
+        if (result) {
+            PyObject* py_parent = (&_Py_NoneStruct);
+            if (parent <= arity_)
+                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);
+
+            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);
+            if (py_child == (&_Py_NoneStruct)) {
+                return result;
+            } else if (py_parent == (&_Py_NoneStruct)) {
+                qptr<T_CHILD> ptr_child(py_child);
+                ptr_child.remove_parent();
+            } else {
+                qptr<T_PARENT> ptr_parent(py_parent);
+                qptr<T_CHILD> ptr_child(py_child);
+
+                if (ptr_parent.is_wrapper()) {
+                    ptr_parent.add_child(ptr_child);
+                } else {
+                    ptr_child.add_cpp_ref();
+                }
+            }
+        }
+        return result;
+    }
+
+};
+
+template < std::size_t parent
+            , std::size_t child
+            , class T_PARENT
+            , class BasePolicy_
+            , class T>
+struct __attribute__ ((visibility("internal"))) parent_policy_add<parent, child, T_PARENT, QList<T*>, BasePolicy_ > : BasePolicy_
+{
+    template <class ArgumentPackage>
+    static PyObject*
+    postcall(ArgumentPackage const& args_, PyObject* result)
+    {
+        unsigned arity_ = boost::python::detail::arity(args_);
+        if ((std::max)(parent, child) > arity_) {
+            return BasePolicy_::postcall(args_, result);
+        }
+
+        result = BasePolicy_::postcall(args_, result);
+        if (result) {
+            PyObject* py_parent = (&_Py_NoneStruct);
+            if (parent <= arity_)
+                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);
+
+            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);
+            if (py_child == (&_Py_NoneStruct) || !((((((PyObject*)(py_child))->ob_type))->tp_flags & ((1L<<25))) != 0)) {
+                return result;
+            } else if (py_parent == (&_Py_NoneStruct)) {
+                Py_ssize_t max = PyList_Size(py_child);
+                for (Py_ssize_t i = 0; i < max; ++i) {
+                    qptr<T> ptr_child(PyList_GetItem(py_child, i));
+                    ptr_child.remove_parent();
+                }
+            } else {
+                Py_ssize_t max = PyList_Size(py_child);
+                qptr<T_PARENT> ptr_parent(py_parent);
+                for (Py_ssize_t i = 0; i < max; ++i) {
+                    qptr<T> ptr_child(PyList_GetItem(py_child, i));
+
+                    if (ptr_parent.is_wrapper()) {
+                       ptr_parent.add_child(ptr_child);
+                    } else {
+                        ptr_child.add_cpp_ref();
+                    }
+                }
+            }
+        }
+        return result;
+    }
+};
+# 179 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
+template <
+    std::size_t arg_index
+  , bool release_ownership
+  , class T
+  , class BasePolicy_ = boost::python::default_call_policies>
+struct __attribute__ ((visibility("internal"))) transfer_ownership : BasePolicy_
+{
+    template <class ArgumentPackage>
+    static PyObject*
+    postcall(ArgumentPackage const& args_, PyObject* result)
+    {
+        unsigned arity_ = boost::python::detail::arity(args_);
+        if (arg_index > arity_) {
+            PyErr_SetString(PyExc_IndexError,
+                            "PySide::transfer_ownership: argument index out of range");
+            return 0;
+        }
+
+        result = BasePolicy_::postcall(args_, result);
+        if (result) {
+            PyObject* py_arg = boost::python::detail::get_prev<arg_index>::execute(args_, result);
+
+            qptr<T> ptr_child(py_arg);
+            if (release_ownership)
+                ptr_child.release_ownership();
+            else
+                ptr_child.acquire_ownership();
+        }
+
+        return result;
+    }
+};
+# 223 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
+template <
+    std::size_t parent
+  , std::size_t child
+  , class T_PARENT
+  , class T_CHILD
+  , class BasePolicy_ = boost::python::default_call_policies
+  , class T = void>
+struct __attribute__ ((visibility("internal"))) parent_policy_remove : BasePolicy_
+{
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((parent != child) == 0 ? false : true) >)> boost_static_assert_typedef_232;
+
+    template <class ArgumentPackage>
+    static PyObject*
+    postcall(ArgumentPackage const& args_, PyObject* result)
+    {
+        unsigned arity_ = boost::python::detail::arity(args_);
+        if ((std::max)(parent, child) > arity_) {
+            PyErr_SetString(PyExc_IndexError,
+                            "PyQt::parent_policy_remove: argument index out of range");
+            return 0;
+        }
+
+        result = BasePolicy_::postcall(args_, result);
+        if (result) {
+            PyObject* py_parent = 0;
+            if (parent <= arity_)
+                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);
+
+            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);
+
+            qptr<T_PARENT> ptr_parent(py_parent);
+            qptr<T_CHILD> ptr_child(py_child);
+
+            if (ptr_parent.is_wrapper()) {
+                ptr_child.remove_parent();
+            } else {
+                ptr_child.remove_cpp_ref();
+            }
+        }
+
+        return result;
+    }
+};
+
+template < std::size_t parent
+            , std::size_t child
+            , class T_PARENT
+            , class BasePolicy_
+            , class T>
+struct __attribute__ ((visibility("internal"))) parent_policy_remove<parent, child, T_PARENT, QList<T*>, BasePolicy_> : BasePolicy_
+{
+    typedef ::boost::static_assert_test< sizeof(::boost::STATIC_ASSERTION_FAILURE< ((parent != child) == 0 ? false : true) >)> boost_static_assert_typedef_274;
+
+    template <class ArgumentPackage>
+    static PyObject*
+    postcall(ArgumentPackage const& args_, PyObject* result)
+    {
+        unsigned arity_ = boost::python::detail::arity(args_);
+        if ((std::max)(parent, child) > arity_) {
+            PyErr_SetString(PyExc_IndexError,
+                            "PyQt::parent_policy_remove: argument index out of range");
+                            return 0;
+        }
+
+        result = BasePolicy_::postcall(args_, result);
+        if (result) {
+            PyObject* py_parent = 0;
+            if (parent <= arity_)
+                py_parent = boost::python::detail::get_prev<parent>::execute(args_, result);
+
+            PyObject* py_child = boost::python::detail::get_prev<child>::execute(args_, result);
+            if (((((((PyObject*)(py_child))->ob_type))->tp_flags & ((1L<<25))) != 0)) {
+                qptr<T_PARENT> ptr_parent(py_parent);
+                uint max = PyList_Size(py_child);
+                for (Py_ssize_t i = 0; i < max; ++i) {
+                    qptr<T> ptr_child(PyList_GetItem(py_child, i));
+
+                    if (ptr_parent.is_wrapper()) {
+                        ptr_child.remove_parent();
+                    } else {
+                        ptr_child.remove_cpp_ref();
+                    }
+                }
+            }
+        }
+        return result;
+    }
+};
+
+
+
+
+
+
+
+template<bool cpp_ownership>
+struct __attribute__ ((visibility("internal"))) make_ptr_reference_holder
+{
+    template <class T>
+    static PyObject*
+    execute(T* p)
+    {
+        if(p == 0)
+        {
+            return boost::python::incref((&_Py_NoneStruct));
+        }
+
+
+        qptr<T> ptr(const_cast<T*>(p));
+        PyObject *ret = ptr.get_pyobject();
+        if (ret)
+            return boost::python::incref(ret);
+
+        ptr.set_pyobject(execute_impl(p));
+
+
+        if (cpp_ownership) {
+            ptr.release_ownership();
+        }
+
+        return ptr.get_pyobject();
+    }
+
+    template <class T>
+    static PyObject*
+    execute_impl(T* p)
+    {
+        typedef qptr<T> smart_pointer;
+        typedef boost::python::objects::pointer_holder<smart_pointer, T> holder_t;
+
+        smart_pointer ptr(const_cast<T*>(p));
+        PyObject *ret = boost::python::objects::make_ptr_instance<T, holder_t>::execute(ptr);
+        ptr.set_pyobject(ret);
+        return ret;
+    }
+};
+# 369 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
+template <bool cpp_ownership = false>
+struct __attribute__ ((visibility("internal"))) return_ptr_object
+{
+    template <class T>
+    struct apply
+    {
+        typedef typename boost::mpl::if_c<
+            boost::is_pointer<T>::value
+            , boost::python::to_python_indirect<T, make_ptr_reference_holder<cpp_ownership> >
+            , boost::python::detail::reference_existing_object_requires_a_pointer_or_reference_return_type<T>
+        >::type type;
+    };
+};
+
+struct __attribute__ ((visibility("internal"))) reference_ptr_object
+{
+    template <class T>
+    struct apply
+    {
+        static const bool ok = boost::is_pointer<T>::value || boost::is_reference<T>::value
+                                                                                    ;
+
+        typedef typename boost::mpl::if_c<
+            ok
+            , boost::python::to_python_indirect<T, make_ptr_reference_holder<false> >
+            , boost::python::detail::reference_existing_object_requires_a_pointer_or_reference_return_type<T>
+        >::type type;
+    };
+};
+# 407 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp"
+template < std::size_t parent_arg
+          , std::size_t child_arg
+          , class T_PARENT
+          , class T_CHILD
+          , class BasePolicy_ = boost::python::default_call_policies
+          , class T = void >
+struct __attribute__ ((visibility("internal"))) return_object
+    : parent_policy_add<parent_arg, child_arg, T_PARENT, T_CHILD, BasePolicy_, T>
+{
+ private:
+    static const bool legal = parent_arg > 0;
+ public:
+    typedef typename boost::mpl::if_c<
+        legal
+        , reference_ptr_object
+        , boost::python::detail::return_internal_reference_owner_arg_must_be_greater_than_zero<parent_arg>
+    >::type result_converter;
+};
+
+template < std::size_t parent_arg
+         , std::size_t child_arg
+         , class T_PARENT
+         , class BasePolicy_
+         , class T >
+struct __attribute__ ((visibility("internal"))) return_object<parent_arg, child_arg, T_PARENT, QList<T>, BasePolicy_>
+: parent_policy_add<parent_arg, child_arg, T_PARENT, QList<T>, BasePolicy_, T>
+{
+};
+
+
+
+
+template<class T>
+inline boost::python::handle<>
+ptr(T* data, bool take_ownership = false)
+{
+    if (data == 0)
+        return boost::python::handle<>(boost::python::incref((&_Py_NoneStruct)));
+
+    PyObject *ret;
+
+    if (take_ownership) {
+        boost::python::to_python_indirect<T, make_ptr_reference_holder<false> >
+                convert;
+        ret = convert(data);
+    } else {
+        boost::python::to_python_indirect<T, make_ptr_reference_holder<true> >
+                convert;
+        ret = convert(data);
+    }
+    return boost::python::handle<>(ret);
+}
+
+}
+# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qcontainer_indexing_suite.hpp" 1
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/qcontainer_indexing_suite.hpp"
+namespace PySide
+{
+
+
+template <class Container, bool NoProxy, class DerivedPolicies>
+class __attribute__ ((visibility("internal"))) qcontainer_indexing_suite;
+
+template <class Container, bool NoProxy>
+class __attribute__ ((visibility("internal"))) final_qcontainer_derived_policies
+    : public qcontainer_indexing_suite<Container, NoProxy,
+                    final_qcontainer_derived_policies<Container, NoProxy> >
+{};
+
+template <class Container,
+          bool NoProxy = false,
+          class DerivedPolicies = final_qcontainer_derived_policies<Container,
+                                                                    NoProxy> >
+class __attribute__ ((visibility("internal"))) qcontainer_indexing_suite
+    : public boost::python::indexing_suite <Container,
+                                            DerivedPolicies,
+                                            NoProxy>
+{
+public:
+    typedef typename Container::value_type data_type;
+    typedef typename Container::value_type key_type;
+    typedef typename Container::size_type index_type;
+    typedef typename Container::size_type size_type;
+    typedef typename Container::difference_type difference_type;
+
+    static typename boost::mpl::if_<boost::is_class<data_type>,
+                                    data_type&,
+                                    data_type>::type
+    get_item(Container& container, index_type i)
+    {
+        return container[i];
+    }
+
+    static boost::python::object
+    get_slice(Container& container, index_type from, index_type to)
+    {
+        if (from > to)
+            return boost::python::object(Container());
+
+        return boost::python::object(container.mid(from, to-from));
+    }
+
+    static void
+    set_item(Container& container, index_type i, data_type const& v)
+    {
+        container[i] = v;
+    }
+
+    static void
+    set_slice(Container& container, index_type from,
+              index_type to, data_type const& v)
+    {
+        if (from > to)
+            return;
+
+        container.erase(container.begin()+from, container.end()+to);
+        container.insert(container.begin()+from, v);
+    }
+
+    template <class Iter>
+    static void
+    set_slice(Container& container, index_type from,
+              index_type to, Iter first, Iter last)
+    {
+        if (from > to) {
+            std::copy(first, last, container.begin()+from);
+        } else {
+            container.erase(container.begin()+from, container.end()+to);
+            std::copy(first, last, container.begin()+from);
+        }
+    }
+
+    static void
+    delete_item(Container& container, index_type i)
+    {
+        container.erase(container.begin()+i);
+    }
+
+    static void
+    delete_slice(Container& container, index_type from, index_type to)
+    {
+        if (from > to)
+            return;
+
+        container.erase(container.begin()+from, container.begin()+to);
+    }
+
+    static size_t
+    size(Container& container)
+    {
+        return container.size();
+    }
+
+    static bool
+    contains(Container& container, key_type const& key)
+    {
+        return std::find(container.begin(), container.end(), key)
+               != container.end();
+    }
+
+    static index_type
+    convert_index(Container& container, PyObject* i_)
+    {
+        boost::python::extract<long> i(i_);
+        if (i.check()) {
+            long index = i();
+            if (index < 0)
+                index += DerivedPolicies::size(container);
+
+            if (index >= long(container.size()) || index < 0) {
+                PyErr_SetString(PyExc_IndexError, "Index out of range");
+                boost::python::throw_error_already_set();
+            }
+            return index;
+        }
+
+        PyErr_SetString(PyExc_TypeError, "Invalid index type");
+        boost::python::throw_error_already_set();
+        return index_type();
+    }
+
+    static index_type
+    get_min_index(Container& )
+    {
+        return 0;
+    }
+
+    static index_type
+    get_max_index(Container& container)
+    {
+        return container.size();
+    }
+
+    static bool
+    compare_index(Container& , index_type a, index_type b)
+    {
+        return a < b;
+    }
+
+    static void
+    append(Container& container, data_type const& v)
+    {
+        container.push_back(v);
+    }
+};
+
+}
+# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 1
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp"
+# 1 "/usr/include/python2.6/pystate.h" 1
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 2
+# 1 "/usr/include/python2.6/ceval.h" 1
+# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 2
+
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/thread_support.hpp" 2
+
+namespace PySide
+{
+
+class __attribute__ ((visibility("default"))) thread_support
+{
+private:
+    static bool m_enabled;
+    thread_support() {}
+
+public:
+    static void init();
+    static void shutdown();
+    static inline bool enabled();
+};
+
+class __attribute__ ((visibility("default"))) thread_locker
+{
+private:
+    PyThreadState *m_thread_state;
+    PyGILState_STATE m_gstate;
+
+public:
+    thread_locker();
+    ~thread_locker();
+};
+
+class __attribute__ ((visibility("default"))) py_allow_threads
+{
+private:
+    PyThreadState *_save;
+
+public:
+    py_allow_threads();
+    ~py_allow_threads();
+};
+
+}
+# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 1
+# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp"
+# 1 "/usr/include/qt4/QtCore/QDebug" 1
+# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QHash" 1
+# 32 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QString" 1
+# 1 "/usr/include/qt4/QtCore/qstring.h" 1
+# 1 "/usr/include/qt4/QtCore/QString" 2
+# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QGenericArgument" 1
+# 1 "/usr/include/qt4/QtCore/qobjectdefs.h" 1
+# 1 "/usr/include/qt4/QtCore/QGenericArgument" 2
+# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QSet" 1
+# 1 "/usr/include/qt4/QtCore/qset.h" 1
+# 1 "/usr/include/qt4/QtCore/QSet" 2
+# 35 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
+
+
+
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 39 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 1
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp"
+# 1 "/usr/include/qt4/QtCore/QString" 1
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QGenericArgument" 1
+# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2
+
+
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/parent_policy.hpp" 1
+# 34 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_details.hpp" 2
+
+namespace PySide
+{
+
+class __attribute__ ((visibility("internal"))) type_details
+{
+    typedef boost::python::object(*func_cpp_to_python_type)(void*);
+    typedef QGenericArgument(*func_python_to_cpp_type)(const boost::python::object&, const char*);
+    typedef void(*func_delete_type)(void*);
+
+
+    type_details() {}
+    type_details(const type_details&);
+    type_details& operator=(const type_details&);
+
+public:
+    template<typename T>
+    static type_details*
+    create_object_type_details(const char* type_name) {
+        type_details* self = new type_details();
+        self->m_type_name = type_name;
+        self->m_type_object = boost::python::converter::registry::query(boost::python::type_id<T>())->get_class_object();
+        self->m_func_cpp_to_python = &objecttype_to_python<T>;
+        self->m_func_python_to_cpp = &python_to_objecttype<T*>;
+        self->m_func_delete = 0;
+        return self;
+    }
+
+    template<typename T>
+    static type_details*
+    create_value_type_details(const char* type_name) {
+        type_details* self = new type_details();
+        self->m_type_name = type_name;
+        self->m_type_object = boost::python::converter::registry::query(boost::python::type_id<T>())->get_class_object();
+        self->m_func_cpp_to_python = &valuetype_to_python<T>;
+        self->m_func_python_to_cpp = &python_to_value_type<T>;
+        self->m_func_delete = &func_delete_data<T>;
+        return self;
+    }
+    template<typename T>
+    static type_details*
+    create_native_type_details(const char* type_name) {
+        type_details* self = new type_details();
+        self->m_type_name = type_name;
+        self->m_type_object = 0;
+        self->m_func_cpp_to_python = &native_to_python<T>;
+        self->m_func_python_to_cpp = &python_to_value_type<T>;
+        self->m_func_delete = &func_delete_data<T>;
+        return self;
+    }
+
+    template<typename T>
+    static type_details*
+    create_container_type_details(const char* type_name) {
+        type_details* self = new type_details();
+        self->m_type_name = type_name;
+        self->m_type_object = 0;
+        self->m_func_cpp_to_python = &container_to_python<T>;
+        self->m_func_python_to_cpp = &python_to_container<T>;
+        self->m_func_delete = &func_delete_data<T>;
+        return self;
+    }
+
+    boost::python::object
+    to_python(void *data) const
+    {
+        return m_func_cpp_to_python(data);
+    }
+
+    QGenericArgument
+    to_cpp(const boost::python::object &obj) const
+    {
+        return m_func_python_to_cpp(obj, m_type_name);
+    }
+
+    const PyTypeObject*
+    get_python_type_object() const
+    {
+        return m_type_object;
+    }
+
+    void
+    delete_data(QGenericArgument &arg) const
+    {
+        if (m_func_delete)
+            m_func_delete(arg.data());
+    }
+
+private:
+    const char* m_type_name;
+    const PyTypeObject *m_type_object;
+
+    func_cpp_to_python_type m_func_cpp_to_python;
+    func_python_to_cpp_type m_func_python_to_cpp;
+    func_delete_type m_func_delete;
+
+
+    template <class T>
+    static boost::python::object
+    objecttype_to_python(void* p)
+    {
+        T* obj = *(reinterpret_cast< T*(*)>(p));
+        boost::python::object py_obj(PySide::ptr(obj));
+        if (!py_obj.ptr())
+        {
+            fprintf(stderr, "Fail to create python object from object in adress: %p\n", obj);
+            py_obj = boost::python::object();
+        }
+        else
+        {
+            boost::python::incref(py_obj.ptr());
+        }
+
+        return py_obj;
+    }
+
+    template <class T>
+    static QGenericArgument
+    python_to_objecttype(const boost::python::object &obj, const char *type_name)
+    {
+        T val = boost::python::extract<T>(obj);
+        return QGenericArgument(type_name, val);
+    }
+
+
+    template <class T>
+    static boost::python::object
+    valuetype_to_python(void* p)
+    {
+        T* val = reinterpret_cast<T*>(p);
+        return boost::python::object(val);
+    }
+
+    template <class T>
+    static QGenericArgument
+    python_to_value_type(const boost::python::object& obj, const char *type_name)
+    {
+        T* val = new T(boost::python::extract<T>(obj));
+        return QGenericArgument(type_name, static_cast<const void*>(val));
+    }
+
+    template <typename T>
+    static QGenericArgument
+    python_to_container(const boost::python::object& obj, const char* type_name)
+    {
+        T* val = new T(boost::python::extract<T>(obj));
+        return QGenericArgument(type_name, static_cast<const void*>(val));
+    }
+
+    template <typename T>
+    static boost::python::object
+    container_to_python(void* p)
+    {
+        return boost::python::object(reinterpret_cast<T*>(p));
+    }
+
+    template<typename T>
+    static boost::python::object
+    container_value_to_python(T t)
+    {
+        return valuetype_to_python<T>(&t);
+    }
+
+    template<typename T>
+    static boost::python::object
+    container_value_to_python(T* t)
+    {
+        return objecttype_to_python<T>(&t);
+    }
+
+    template <class T>
+    static void
+    func_delete_data(void *data)
+    {
+        delete reinterpret_cast<T*>(data);
+    }
+
+    template<typename T>
+    static boost::python::object
+    native_to_python(void* p)
+    {
+        T* val = new T(*reinterpret_cast<T*>(p));
+        return boost::python::object(*val);
+    }
+};
+
+}
+# 40 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/type_manager.hpp" 2
+
+
+namespace PySide
+{
+
+class __attribute__ ((visibility("default"))) type_manager
+{
+public:
+    static type_manager& instance();
+    ~type_manager();
+
+    boost::python::object to_python(const QString &name, void *data);
+    QGenericArgument to_cpp(const QString &name, const boost::python::object &obj);
+    void delete_data(QGenericArgument &arg);
+
+    template<typename T>
+    void __attribute__ ((visibility("internal")))
+    register_object_type(const char* type_name)
+    {
+        m_type_map[type_name] = type_details::create_object_type_details<T>(type_name);
+    }
+
+    template<typename T>
+    void __attribute__ ((visibility("internal")))
+    register_value_type(const char* type_name)
+    {
+        m_type_map[type_name] = type_details::create_value_type_details<T>(type_name);
+    }
+
+    template<typename T>
+    void __attribute__ ((visibility("internal")))
+    register_native_type(const char* type_name)
+    {
+        m_type_map[type_name] = type_details::create_native_type_details<T>(type_name);
+    }
+
+    template<typename T>
+    void __attribute__ ((visibility("internal")))
+    register_container_type(const char* type_name)
+    {
+        m_type_map[type_name] = type_details::create_container_type_details<T>(type_name);
+    }
+
+
+    bool __attribute__ ((visibility("internal")))
+    register_converter(const char* type_name) {
+        QString key(type_name);
+         if (m_registered_converters.contains(key))
+            return false;
+         m_registered_converters << key;
+         return true;
+    }
+
+    const type_details*
+    get_type_details(const char* type_name)
+    {
+        return m_type_map[type_name];
+    }
+
+
+private:
+    QSet<QString> m_registered_converters;
+    QHash<QString, type_details* > m_type_map;
+    type_manager();
+    type_manager(const type_manager&);
+};
+
+}
+# 35 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 1
+# 27 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
+# 1 "/usr/include/qt4/QtCore/QHash" 1
+# 28 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QList" 1
+# 1 "/usr/include/qt4/QtCore/qlist.h" 1
+# 1 "/usr/include/qt4/QtCore/QList" 2
+# 29 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
+# 1 "/usr/include/qt4/QtCore/QByteArray" 1
+# 1 "/usr/include/qt4/QtCore/qbytearray.h" 1
+# 1 "/usr/include/qt4/QtCore/QByteArray" 2
+# 30 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside_global.hpp" 1
+# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
+
+# 1 "/usr/include/qt4/QtCore/QMap" 1
+# 1 "/usr/include/qt4/QtCore/qmap.h" 1
+# 1 "/usr/include/qt4/QtCore/QMap" 2
+# 33 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp" 2
+
+class QObject;
+
+namespace PySide
+{
+
+class signal_holder;
+class pyqt_signal;
+class pyqt_slot;
+class trigger;
+
+struct signal_manager_data;
+# 63 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
+class __attribute__ ((visibility("default"))) signal_manager
+{
+public:
+
+    static signal_manager& instance();
+
+
+    bool connect(QObject* src, const pyqt_signal& signal,
+                 boost::python::object& callable, Qt::ConnectionType type = Qt::AutoConnection);
+
+    bool connect(QObject* sender, const pyqt_signal& signal,
+                 QObject* receiver, const pyqt_slot& slot, Qt::ConnectionType type = Qt::AutoConnection);
+
+    bool disconnect(QObject* src, const pyqt_signal& signal,
+                    boost::python::object& callable);
+
+    bool disconnect(QObject* sender, const pyqt_signal& signal,
+                    QObject* receiver,
+                    const pyqt_slot& slot);
+
+    int dynamicsignal_receivers(const QObject *sender,
+                                const pyqt_signal &signal,
+                                int offset) const;
+    QList<QByteArray> signals_of(const QObject* obj);
+# 96 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
+    void register_dynamic_signal(QObject *src, const pyqt_signal& signal,
+                                 trigger* trigger, int slot_id);
+# 107 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
+    QObject* register_dynamic_signal(QObject *parent,
+                                     QObject *sender,
+                                     const pyqt_signal& signal,
+                                     const pyqt_signal& receiver);
+# 119 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/signal_manager.hpp"
+    QObject* register_dynamic_slot(QObject *parent,
+                                     const boost::python::object &callback,
+                                     QString &slot_name);
+
+
+    const QMetaObject* get_dynamic_metaobject(QObject* obj);
+
+
+    void unregister_qobj(QObject* obj);
+
+
+    void emit_(QObject *src, const pyqt_signal& signal,
+               const boost::python::object& args);
+
+    ~signal_manager();
+
+    void register_sender(QObject* sender);
+    void unregister_sender();
+    QObject* sender();
+
+private:
+    signal_manager_data *m_data;
+
+    trigger* find_trigger(QObject* src);
+    trigger* get_trigger(const QObject *src) const;
+    void emit_dynamic_signal(QObject *source, const pyqt_signal& signal,
+                             const boost::python::object& args);
+    void emit_native_signal(QObject *source, int signal_index,
+                            const pyqt_signal& signal,
+                            const boost::python::object& args);
+    void parse_objects_to_qarguments(const QStringList &args_type,
+                                     const boost::python::object &argv,
+                                     QList<QGenericArgument> &q_args);
+
+
+    signal_manager();
+    signal_manager(const signal_manager&);
+    signal_manager& operator=(const signal_manager&);
+};
+
+class __attribute__ ((visibility("internal"))) set_sender
+{
+    signal_manager& m_sm;
+
+public:
+    set_sender(QObject* sender) : m_sm(signal_manager::instance())
+    {
+        m_sm.register_sender(sender);
+    }
+
+    ~set_sender()
+    {
+        m_sm.unregister_sender();
+    }
+};
+
+}
+# 37 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3/base/pyside.hpp" 2
+# 35 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp" 2
+# 1 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.hpp" 1
+# 31 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.hpp"
+using namespace PySide;
+
+class __attribute__ ((visibility("internal"))) qwebpage_extensionoption_wrapper : public QWebPage::ExtensionOption, public PySide::wrapper
+{
+
+private:
+    typedef boost::python::class_< QWebPage::ExtensionOption, PySide::qptr < qwebpage_extensionoption_wrapper, qptr_base::no_check_cache | qptr_base::wrapper_pointer> > class_type;
+public:
+    qwebpage_extensionoption_wrapper(PyObject *py_self, const QWebPage::ExtensionOption& self) : QWebPage::ExtensionOption(self), wrapper(py_self)
+    {
+    }
+    qwebpage_extensionoption_wrapper(PyObject *py_self);
+    ~qwebpage_extensionoption_wrapper();
+
+    static void define_python_class() throw();
+
+};
+# 36 "/var/tmp/portage/dev-python/pyside-0.2.3-r1/work/pyside-qt4.6+0.2.3_build/PySide/QtWebKit/PySide/QtWebKit/qwebpage_extensionoption_wrapper.cpp" 2
+
+
+
+
+using namespace boost;
+using namespace PySide;
+
+qwebpage_extensionoption_wrapper::qwebpage_extensionoption_wrapper(PyObject *py_self)
+ : QWebPage::ExtensionOption(), wrapper(py_self)
+{
+}
+
+qwebpage_extensionoption_wrapper::~qwebpage_extensionoption_wrapper()
+{
+    PySide::qptr_base::invalidate(PySide::qptr<QWebPage::ExtensionOption >::get_void_pointer(this));
+}
+void qwebpage_extensionoption_wrapper::define_python_class() throw() {
+    class_type python_cls("ExtensionOption", python::init< > ());
+
+    python::scope qwebpage_extensionoption_wrapper_scope(python_cls);
+    python::implicitly_convertible< PySide::qptr<qwebpage_extensionoption_wrapper>, PySide::qptr<QWebPage::ExtensionOption> >();
+    python_cls.def(python::init<const QWebPage::ExtensionOption&>());
+    type_manager::instance().register_value_type<QWebPage::ExtensionOption >("QWebPage::ExtensionOption");
+}