{"action":"created","comment":{"url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/comments/211260434","pull_request_review_id":147642398,"id":211260434,"node_id":"MDI0OlB1bGxSZXF1ZXN0UmV2aWV3Q29tbWVudDIxMTI2MDQzNA==","diff_hunk":"@@ -0,0 +1,5947 @@\n+/* ----------------------------------------------------------------------------\n+ * This file was automatically generated by SWIG (http://www.swig.org).\n+ * Version 3.0.8\n+ *\n+ * This file is not intended to be easily readable and contains a number of\n+ * coding conventions designed to improve portability and efficiency. Do not make\n+ * changes to this file unless you know what you are doing--modify the SWIG\n+ * interface file instead.\n+ * ----------------------------------------------------------------------------- */\n+\n+\n+#ifndef SWIGPYTHON\n+#define SWIGPYTHON\n+#endif\n+\n+#define SWIG_PYTHON_DIRECTOR_NO_VTABLE\n+\n+\n+#ifdef __cplusplus\n+/* SwigValueWrapper is described in swig.swg */\n+template<typename T> class SwigValueWrapper {\n+  struct SwigMovePointer {\n+    T *ptr;\n+    SwigMovePointer(T *p) : ptr(p) { }\n+    ~SwigMovePointer() { delete ptr; }\n+    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }\n+  } pointer;\n+  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);\n+  SwigValueWrapper(const SwigValueWrapper<T>& rhs);\n+public:\n+  SwigValueWrapper() : pointer(0) { }\n+  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }\n+  operator T&() const { return *pointer.ptr; }\n+  T *operator&() { return pointer.ptr; }\n+};\n+\n+template <typename T> T SwigValueInit() {\n+  return T();\n+}\n+#endif\n+\n+/* -----------------------------------------------------------------------------\n+ *  This section contains generic SWIG labels for method/variable\n+ *  declarations/attributes, and other compiler dependent labels.\n+ * ----------------------------------------------------------------------------- */\n+\n+/* template workaround for compilers that cannot correctly implement the C++ standard */\n+#ifndef SWIGTEMPLATEDISAMBIGUATOR\n+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)\n+#  define SWIGTEMPLATEDISAMBIGUATOR template\n+# elif defined(__HP_aCC)\n+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */\n+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */\n+#  define SWIGTEMPLATEDISAMBIGUATOR template\n+# else\n+#  define SWIGTEMPLATEDISAMBIGUATOR\n+# endif\n+#endif\n+\n+/* inline attribute */\n+#ifndef SWIGINLINE\n+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))\n+#   define SWIGINLINE inline\n+# else\n+#   define SWIGINLINE\n+# endif\n+#endif\n+\n+/* attribute recognised by some compilers to avoid 'unused' warnings */\n+#ifndef SWIGUNUSED\n+# if defined(__GNUC__)\n+#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))\n+#     define SWIGUNUSED __attribute__ ((__unused__))\n+#   else\n+#     define SWIGUNUSED\n+#   endif\n+# elif defined(__ICC)\n+#   define SWIGUNUSED __attribute__ ((__unused__))\n+# else\n+#   define SWIGUNUSED\n+# endif\n+#endif\n+\n+#ifndef SWIG_MSC_UNSUPPRESS_4505\n+# if defined(_MSC_VER)\n+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */\n+# endif\n+#endif\n+\n+#ifndef SWIGUNUSEDPARM\n+# ifdef __cplusplus\n+#   define SWIGUNUSEDPARM(p)\n+# else\n+#   define SWIGUNUSEDPARM(p) p SWIGUNUSED\n+# endif\n+#endif\n+\n+/* internal SWIG method */\n+#ifndef SWIGINTERN\n+# define SWIGINTERN static SWIGUNUSED\n+#endif\n+\n+/* internal inline SWIG method */\n+#ifndef SWIGINTERNINLINE\n+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE\n+#endif\n+\n+/* exporting methods */\n+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)\n+#  ifndef GCC_HASCLASSVISIBILITY\n+#    define GCC_HASCLASSVISIBILITY\n+#  endif\n+#endif\n+\n+#ifndef SWIGEXPORT\n+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)\n+#   if defined(STATIC_LINKED)\n+#     define SWIGEXPORT\n+#   else\n+#     define SWIGEXPORT __declspec(dllexport)\n+#   endif\n+# else\n+#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)\n+#     define SWIGEXPORT __attribute__ ((visibility(\"default\")))\n+#   else\n+#     define SWIGEXPORT\n+#   endif\n+# endif\n+#endif\n+\n+/* calling conventions for Windows */\n+#ifndef SWIGSTDCALL\n+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)\n+#   define SWIGSTDCALL __stdcall\n+# else\n+#   define SWIGSTDCALL\n+# endif\n+#endif\n+\n+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */\n+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)\n+# define _CRT_SECURE_NO_DEPRECATE\n+#endif\n+\n+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */\n+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)\n+# define _SCL_SECURE_NO_DEPRECATE\n+#endif\n+\n+/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */\n+#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)\n+# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0\n+#endif\n+\n+/* Intel's compiler complains if a variable which was never initialised is\n+ * cast to void, which is a common idiom which we use to indicate that we\n+ * are aware a variable isn't used.  So we just silence that warning.\n+ * See: https://github.com/swig/swig/issues/192 for more discussion.\n+ */\n+#ifdef __INTEL_COMPILER\n+# pragma warning disable 592\n+#endif\n+\n+\n+#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)\n+/* Use debug wrappers with the Python release dll */\n+# undef _DEBUG\n+# include <Python.h>\n+# define _DEBUG\n+#else\n+# include <Python.h>\n+#endif\n+\n+/* -----------------------------------------------------------------------------\n+ * swigrun.swg\n+ *\n+ * This file contains generic C API SWIG runtime support for pointer\n+ * type checking.\n+ * ----------------------------------------------------------------------------- */\n+\n+/* This should only be incremented when either the layout of swig_type_info changes,\n+   or for whatever reason, the runtime changes incompatibly */\n+#define SWIG_RUNTIME_VERSION \"4\"\n+\n+/* define SWIG_TYPE_TABLE_NAME as \"SWIG_TYPE_TABLE\" */\n+#ifdef SWIG_TYPE_TABLE\n+# define SWIG_QUOTE_STRING(x) #x\n+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)\n+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)\n+#else\n+# define SWIG_TYPE_TABLE_NAME\n+#endif\n+\n+/*\n+  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for\n+  creating a static or dynamic library from the SWIG runtime code.\n+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.\n+\n+  But only do this if strictly necessary, ie, if you have problems\n+  with your compiler or suchlike.\n+*/\n+\n+#ifndef SWIGRUNTIME\n+# define SWIGRUNTIME SWIGINTERN\n+#endif\n+\n+#ifndef SWIGRUNTIMEINLINE\n+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE\n+#endif\n+\n+/*  Generic buffer size */\n+#ifndef SWIG_BUFFER_SIZE\n+# define SWIG_BUFFER_SIZE 1024\n+#endif\n+\n+/* Flags for pointer conversions */\n+#define SWIG_POINTER_DISOWN        0x1\n+#define SWIG_CAST_NEW_MEMORY       0x2\n+\n+/* Flags for new pointer objects */\n+#define SWIG_POINTER_OWN           0x1\n+\n+\n+/*\n+   Flags/methods for returning states.\n+\n+   The SWIG conversion methods, as ConvertPtr, return an integer\n+   that tells if the conversion was successful or not. And if not,\n+   an error code can be returned (see swigerrors.swg for the codes).\n+\n+   Use the following macros/flags to set or process the returning\n+   states.\n+\n+   In old versions of SWIG, code such as the following was usually written:\n+\n+     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {\n+       // success code\n+     } else {\n+       //fail code\n+     }\n+\n+   Now you can be more explicit:\n+\n+    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);\n+    if (SWIG_IsOK(res)) {\n+      // success code\n+    } else {\n+      // fail code\n+    }\n+\n+   which is the same really, but now you can also do\n+\n+    Type *ptr;\n+    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);\n+    if (SWIG_IsOK(res)) {\n+      // success code\n+      if (SWIG_IsNewObj(res) {\n+        ...\n+\tdelete *ptr;\n+      } else {\n+        ...\n+      }\n+    } else {\n+      // fail code\n+    }\n+\n+   I.e., now SWIG_ConvertPtr can return new objects and you can\n+   identify the case and take care of the deallocation. Of course that\n+   also requires SWIG_ConvertPtr to return new result values, such as\n+\n+      int SWIG_ConvertPtr(obj, ptr,...) {\n+        if (<obj is ok>) {\n+          if (<need new object>) {\n+            *ptr = <ptr to new allocated object>;\n+            return SWIG_NEWOBJ;\n+          } else {\n+            *ptr = <ptr to old object>;\n+            return SWIG_OLDOBJ;\n+          }\n+        } else {\n+          return SWIG_BADOBJ;\n+        }\n+      }\n+\n+   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be\n+   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the\n+   SWIG errors code.\n+\n+   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code\n+   allows to return the 'cast rank', for example, if you have this\n+\n+       int food(double)\n+       int fooi(int);\n+\n+   and you call\n+\n+      food(1)   // cast rank '1'  (1 -> 1.0)\n+      fooi(1)   // cast rank '0'\n+\n+   just use the SWIG_AddCast()/SWIG_CheckState()\n+*/\n+\n+#define SWIG_OK                    (0)\n+#define SWIG_ERROR                 (-1)\n+#define SWIG_IsOK(r)               (r >= 0)\n+#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)\n+\n+/* The CastRankLimit says how many bits are used for the cast rank */\n+#define SWIG_CASTRANKLIMIT         (1 << 8)\n+/* The NewMask denotes the object was created (using new/malloc) */\n+#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)\n+/* The TmpMask is for in/out typemaps that use temporal objects */\n+#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)\n+/* Simple returning values */\n+#define SWIG_BADOBJ                (SWIG_ERROR)\n+#define SWIG_OLDOBJ                (SWIG_OK)\n+#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)\n+#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)\n+/* Check, add and del mask methods */\n+#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)\n+#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)\n+#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))\n+#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)\n+#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)\n+#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))\n+\n+/* Cast-Rank Mode */\n+#if defined(SWIG_CASTRANK_MODE)\n+#  ifndef SWIG_TypeRank\n+#    define SWIG_TypeRank             unsigned long\n+#  endif\n+#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */\n+#    define SWIG_MAXCASTRANK          (2)\n+#  endif\n+#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)\n+#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)\n+SWIGINTERNINLINE int SWIG_AddCast(int r) {\n+  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;\n+}\n+SWIGINTERNINLINE int SWIG_CheckState(int r) {\n+  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;\n+}\n+#else /* no cast-rank mode */\n+#  define SWIG_AddCast(r) (r)\n+#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)\n+#endif\n+\n+\n+#include <string.h>\n+\n+#ifdef __cplusplus\n+extern \"C\" {\n+#endif\n+\n+typedef void *(*swig_converter_func)(void *, int *);\n+typedef struct swig_type_info *(*swig_dycast_func)(void **);\n+\n+/* Structure to store information on one type */\n+typedef struct swig_type_info {\n+  const char             *name;\t\t\t/* mangled name of this type */\n+  const char             *str;\t\t\t/* human readable name of this type */\n+  swig_dycast_func        dcast;\t\t/* dynamic cast function down a hierarchy */\n+  struct swig_cast_info  *cast;\t\t\t/* linked list of types that can cast into this type */\n+  void                   *clientdata;\t\t/* language specific type data */\n+  int                    owndata;\t\t/* flag if the structure owns the clientdata */\n+} swig_type_info;\n+\n+/* Structure to store a type and conversion function used for casting */\n+typedef struct swig_cast_info {\n+  swig_type_info         *type;\t\t\t/* pointer to type that is equivalent to this type */\n+  swig_converter_func     converter;\t\t/* function to cast the void pointers */\n+  struct swig_cast_info  *next;\t\t\t/* pointer to next cast in linked list */\n+  struct swig_cast_info  *prev;\t\t\t/* pointer to the previous cast */\n+} swig_cast_info;\n+\n+/* Structure used to store module information\n+ * Each module generates one structure like this, and the runtime collects\n+ * all of these structures and stores them in a circularly linked list.*/\n+typedef struct swig_module_info {\n+  swig_type_info         **types;\t\t/* Array of pointers to swig_type_info structures that are in this module */\n+  size_t                 size;\t\t        /* Number of types in this module */\n+  struct swig_module_info *next;\t\t/* Pointer to next element in circularly linked list */\n+  swig_type_info         **type_initial;\t/* Array of initially generated type structures */\n+  swig_cast_info         **cast_initial;\t/* Array of initially generated casting structures */\n+  void                    *clientdata;\t\t/* Language specific module data */\n+} swig_module_info;\n+\n+/*\n+  Compare two type names skipping the space characters, therefore\n+  \"char*\" == \"char *\" and \"Class<int>\" == \"Class<int >\", etc.\n+\n+  Return 0 when the two name types are equivalent, as in\n+  strncmp, but skipping ' '.\n+*/\n+SWIGRUNTIME int\n+SWIG_TypeNameComp(const char *f1, const char *l1,\n+\t\t  const char *f2, const char *l2) {\n+  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {\n+    while ((*f1 == ' ') && (f1 != l1)) ++f1;\n+    while ((*f2 == ' ') && (f2 != l2)) ++f2;\n+    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;\n+  }\n+  return (int)((l1 - f1) - (l2 - f2));\n+}\n+\n+/*\n+  Check type equivalence in a name list like <name1>|<name2>|...\n+  Return 0 if equal, -1 if nb < tb, 1 if nb > tb\n+*/\n+SWIGRUNTIME int\n+SWIG_TypeCmp(const char *nb, const char *tb) {\n+  int equiv = 1;\n+  const char* te = tb + strlen(tb);\n+  const char* ne = nb;\n+  while (equiv != 0 && *ne) {\n+    for (nb = ne; *ne; ++ne) {\n+      if (*ne == '|') break;\n+    }\n+    equiv = SWIG_TypeNameComp(nb, ne, tb, te);\n+    if (*ne) ++ne;\n+  }\n+  return equiv;\n+}\n+\n+/*\n+  Check type equivalence in a name list like <name1>|<name2>|...\n+  Return 0 if not equal, 1 if equal\n+*/\n+SWIGRUNTIME int\n+SWIG_TypeEquiv(const char *nb, const char *tb) {\n+  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;\n+}\n+\n+/*\n+  Check the typename\n+*/\n+SWIGRUNTIME swig_cast_info *\n+SWIG_TypeCheck(const char *c, swig_type_info *ty) {\n+  if (ty) {\n+    swig_cast_info *iter = ty->cast;\n+    while (iter) {\n+      if (strcmp(iter->type->name, c) == 0) {\n+        if (iter == ty->cast)\n+          return iter;\n+        /* Move iter to the top of the linked list */\n+        iter->prev->next = iter->next;\n+        if (iter->next)\n+          iter->next->prev = iter->prev;\n+        iter->next = ty->cast;\n+        iter->prev = 0;\n+        if (ty->cast) ty->cast->prev = iter;\n+        ty->cast = iter;\n+        return iter;\n+      }\n+      iter = iter->next;\n+    }\n+  }\n+  return 0;\n+}\n+\n+/*\n+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison\n+*/\n+SWIGRUNTIME swig_cast_info *\n+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {\n+  if (ty) {\n+    swig_cast_info *iter = ty->cast;\n+    while (iter) {\n+      if (iter->type == from) {\n+        if (iter == ty->cast)\n+          return iter;\n+        /* Move iter to the top of the linked list */\n+        iter->prev->next = iter->next;\n+        if (iter->next)\n+          iter->next->prev = iter->prev;\n+        iter->next = ty->cast;\n+        iter->prev = 0;\n+        if (ty->cast) ty->cast->prev = iter;\n+        ty->cast = iter;\n+        return iter;\n+      }\n+      iter = iter->next;\n+    }\n+  }\n+  return 0;\n+}\n+\n+/*\n+  Cast a pointer up an inheritance hierarchy\n+*/\n+SWIGRUNTIMEINLINE void *\n+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {\n+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);\n+}\n+\n+/*\n+   Dynamic pointer casting. Down an inheritance hierarchy\n+*/\n+SWIGRUNTIME swig_type_info *\n+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {\n+  swig_type_info *lastty = ty;\n+  if (!ty || !ty->dcast) return ty;\n+  while (ty && (ty->dcast)) {\n+    ty = (*ty->dcast)(ptr);\n+    if (ty) lastty = ty;\n+  }\n+  return lastty;\n+}\n+\n+/*\n+  Return the name associated with this type\n+*/\n+SWIGRUNTIMEINLINE const char *\n+SWIG_TypeName(const swig_type_info *ty) {\n+  return ty->name;\n+}\n+\n+/*\n+  Return the pretty name associated with this type,\n+  that is an unmangled type name in a form presentable to the user.\n+*/\n+SWIGRUNTIME const char *\n+SWIG_TypePrettyName(const swig_type_info *type) {\n+  /* The \"str\" field contains the equivalent pretty names of the\n+     type, separated by vertical-bar characters.  We choose\n+     to print the last name, as it is often (?) the most\n+     specific. */\n+  if (!type) return NULL;\n+  if (type->str != NULL) {\n+    const char *last_name = type->str;\n+    const char *s;\n+    for (s = type->str; *s; s++)\n+      if (*s == '|') last_name = s+1;\n+    return last_name;\n+  }\n+  else\n+    return type->name;\n+}\n+\n+/*\n+   Set the clientdata field for a type\n+*/\n+SWIGRUNTIME void\n+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {\n+  swig_cast_info *cast = ti->cast;\n+  /* if (ti->clientdata == clientdata) return; */\n+  ti->clientdata = clientdata;\n+\n+  while (cast) {\n+    if (!cast->converter) {\n+      swig_type_info *tc = cast->type;\n+      if (!tc->clientdata) {\n+\tSWIG_TypeClientData(tc, clientdata);\n+      }\n+    }\n+    cast = cast->next;\n+  }\n+}\n+SWIGRUNTIME void\n+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {\n+  SWIG_TypeClientData(ti, clientdata);\n+  ti->owndata = 1;\n+}\n+\n+/*\n+  Search for a swig_type_info structure only by mangled name\n+  Search is a O(log #types)\n+\n+  We start searching at module start, and finish searching when start == end.\n+  Note: if start == end at the beginning of the function, we go all the way around\n+  the circular list.\n+*/\n+SWIGRUNTIME swig_type_info *\n+SWIG_MangledTypeQueryModule(swig_module_info *start,\n+                            swig_module_info *end,\n+\t\t            const char *name) {\n+  swig_module_info *iter = start;\n+  do {\n+    if (iter->size) {\n+      size_t l = 0;\n+      size_t r = iter->size - 1;\n+      do {\n+\t/* since l+r >= 0, we can (>> 1) instead (/ 2) */\n+\tsize_t i = (l + r) >> 1;\n+\tconst char *iname = iter->types[i]->name;\n+\tif (iname) {\n+\t  int compare = strcmp(name, iname);\n+\t  if (compare == 0) {\n+\t    return iter->types[i];\n+\t  } else if (compare < 0) {\n+\t    if (i) {\n+\t      r = i - 1;\n+\t    } else {\n+\t      break;\n+\t    }\n+\t  } else if (compare > 0) {\n+\t    l = i + 1;\n+\t  }\n+\t} else {\n+\t  break; /* should never happen */\n+\t}\n+      } while (l <= r);\n+    }\n+    iter = iter->next;\n+  } while (iter != end);\n+  return 0;\n+}\n+\n+/*\n+  Search for a swig_type_info structure for either a mangled name or a human readable name.\n+  It first searches the mangled names of the types, which is a O(log #types)\n+  If a type is not found it then searches the human readable names, which is O(#types).\n+\n+  We start searching at module start, and finish searching when start == end.\n+  Note: if start == end at the beginning of the function, we go all the way around\n+  the circular list.\n+*/\n+SWIGRUNTIME swig_type_info *\n+SWIG_TypeQueryModule(swig_module_info *start,\n+                     swig_module_info *end,\n+\t\t     const char *name) {\n+  /* STEP 1: Search the name field using binary search */\n+  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);\n+  if (ret) {\n+    return ret;\n+  } else {\n+    /* STEP 2: If the type hasn't been found, do a complete search\n+       of the str field (the human readable name) */\n+    swig_module_info *iter = start;\n+    do {\n+      size_t i = 0;\n+      for (; i < iter->size; ++i) {\n+\tif (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))\n+\t  return iter->types[i];\n+      }\n+      iter = iter->next;\n+    } while (iter != end);\n+  }\n+\n+  /* neither found a match */\n+  return 0;\n+}\n+\n+/*\n+   Pack binary data into a string\n+*/\n+SWIGRUNTIME char *\n+SWIG_PackData(char *c, void *ptr, size_t sz) {\n+  static const char hex[17] = \"0123456789abcdef\";\n+  const unsigned char *u = (unsigned char *) ptr;\n+  const unsigned char *eu =  u + sz;\n+  for (; u != eu; ++u) {\n+    unsigned char uu = *u;\n+    *(c++) = hex[(uu & 0xf0) >> 4];\n+    *(c++) = hex[uu & 0xf];\n+  }\n+  return c;\n+}\n+\n+/*\n+   Unpack binary data from a string\n+*/\n+SWIGRUNTIME const char *\n+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {\n+  unsigned char *u = (unsigned char *) ptr;\n+  const unsigned char *eu = u + sz;\n+  for (; u != eu; ++u) {\n+    char d = *(c++);\n+    unsigned char uu;\n+    if ((d >= '0') && (d <= '9'))\n+      uu = ((d - '0') << 4);\n+    else if ((d >= 'a') && (d <= 'f'))\n+      uu = ((d - ('a'-10)) << 4);\n+    else\n+      return (char *) 0;\n+    d = *(c++);\n+    if ((d >= '0') && (d <= '9'))\n+      uu |= (d - '0');\n+    else if ((d >= 'a') && (d <= 'f'))\n+      uu |= (d - ('a'-10));\n+    else\n+      return (char *) 0;\n+    *u = uu;\n+  }\n+  return c;\n+}\n+\n+/*\n+   Pack 'void *' into a string buffer.\n+*/\n+SWIGRUNTIME char *\n+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {\n+  char *r = buff;\n+  if ((2*sizeof(void *) + 2) > bsz) return 0;\n+  *(r++) = '_';\n+  r = SWIG_PackData(r,&ptr,sizeof(void *));\n+  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;\n+  strcpy(r,name);\n+  return buff;\n+}\n+\n+SWIGRUNTIME const char *\n+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {\n+  if (*c != '_') {\n+    if (strcmp(c,\"NULL\") == 0) {\n+      *ptr = (void *) 0;\n+      return name;\n+    } else {\n+      return 0;\n+    }\n+  }\n+  return SWIG_UnpackData(++c,ptr,sizeof(void *));\n+}\n+\n+SWIGRUNTIME char *\n+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {\n+  char *r = buff;\n+  size_t lname = (name ? strlen(name) : 0);\n+  if ((2*sz + 2 + lname) > bsz) return 0;\n+  *(r++) = '_';\n+  r = SWIG_PackData(r,ptr,sz);\n+  if (lname) {\n+    strncpy(r,name,lname+1);\n+  } else {\n+    *r = 0;\n+  }\n+  return buff;\n+}\n+\n+SWIGRUNTIME const char *\n+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {\n+  if (*c != '_') {\n+    if (strcmp(c,\"NULL\") == 0) {\n+      memset(ptr,0,sz);\n+      return name;\n+    } else {\n+      return 0;\n+    }\n+  }\n+  return SWIG_UnpackData(++c,ptr,sz);\n+}\n+\n+#ifdef __cplusplus\n+}\n+#endif\n+\n+/*  Errors in SWIG */\n+#define  SWIG_UnknownError    \t   -1\n+#define  SWIG_IOError        \t   -2\n+#define  SWIG_RuntimeError   \t   -3\n+#define  SWIG_IndexError     \t   -4\n+#define  SWIG_TypeError      \t   -5\n+#define  SWIG_DivisionByZero \t   -6\n+#define  SWIG_OverflowError  \t   -7\n+#define  SWIG_SyntaxError    \t   -8\n+#define  SWIG_ValueError     \t   -9\n+#define  SWIG_SystemError    \t   -10\n+#define  SWIG_AttributeError \t   -11\n+#define  SWIG_MemoryError    \t   -12\n+#define  SWIG_NullReferenceError   -13\n+\n+\n+\n+/* Compatibility macros for Python 3 */\n+#if PY_VERSION_HEX >= 0x03000000\n+\n+#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)\n+#define PyInt_Check(x) PyLong_Check(x)\n+#define PyInt_AsLong(x) PyLong_AsLong(x)\n+#define PyInt_FromLong(x) PyLong_FromLong(x)\n+#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)\n+#define PyString_Check(name) PyBytes_Check(name)\n+#define PyString_FromString(x) PyUnicode_FromString(x)\n+#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)\n+#define PyString_AsString(str) PyBytes_AsString(str)\n+#define PyString_Size(str) PyBytes_Size(str)\t\n+#define PyString_InternFromString(key) PyUnicode_InternFromString(key)\n+#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE\n+#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)\n+#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)\n+\n+#endif\n+\n+#ifndef Py_TYPE\n+#  define Py_TYPE(op) ((op)->ob_type)\n+#endif\n+\n+/* SWIG APIs for compatibility of both Python 2 & 3 */\n+\n+#if PY_VERSION_HEX >= 0x03000000\n+#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat\n+#else\n+#  define SWIG_Python_str_FromFormat PyString_FromFormat\n+#endif\n+\n+\n+/* Warning: This function will allocate a new string in Python 3,\n+ * so please call SWIG_Python_str_DelForPy3(x) to free the space.\n+ */\n+SWIGINTERN char*\n+SWIG_Python_str_AsChar(PyObject *str)\n+{\n+#if PY_VERSION_HEX >= 0x03000000\n+  char *cstr;\n+  char *newstr;\n+  Py_ssize_t len;\n+  str = PyUnicode_AsUTF8String(str);\n+  PyBytes_AsStringAndSize(str, &cstr, &len);\n+  newstr = (char *) malloc(len+1);\n+  memcpy(newstr, cstr, len+1);\n+  Py_XDECREF(str);\n+  return newstr;\n+#else\n+  return PyString_AsString(str);\n+#endif\n+}\n+\n+#if PY_VERSION_HEX >= 0x03000000\n+#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )\n+#else\n+#  define SWIG_Python_str_DelForPy3(x) \n+#endif\n+\n+\n+SWIGINTERN PyObject*\n+SWIG_Python_str_FromChar(const char *c)\n+{\n+#if PY_VERSION_HEX >= 0x03000000\n+  return PyUnicode_FromString(c); \n+#else\n+  return PyString_FromString(c);\n+#endif\n+}\n+\n+/* Add PyOS_snprintf for old Pythons */\n+#if PY_VERSION_HEX < 0x02020000\n+# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)\n+#  define PyOS_snprintf _snprintf\n+# else\n+#  define PyOS_snprintf snprintf\n+# endif\n+#endif\n+\n+/* A crude PyString_FromFormat implementation for old Pythons */\n+#if PY_VERSION_HEX < 0x02020000\n+\n+#ifndef SWIG_PYBUFFER_SIZE\n+# define SWIG_PYBUFFER_SIZE 1024\n+#endif\n+\n+static PyObject *\n+PyString_FromFormat(const char *fmt, ...) {\n+  va_list ap;\n+  char buf[SWIG_PYBUFFER_SIZE * 2];\n+  int res;\n+  va_start(ap, fmt);\n+  res = vsnprintf(buf, sizeof(buf), fmt, ap);\n+  va_end(ap);\n+  return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);\n+}\n+#endif\n+\n+/* Add PyObject_Del for old Pythons */\n+#if PY_VERSION_HEX < 0x01060000\n+# define PyObject_Del(op) PyMem_DEL((op))\n+#endif\n+#ifndef PyObject_DEL\n+# define PyObject_DEL PyObject_Del\n+#endif\n+\n+/* A crude PyExc_StopIteration exception for old Pythons */\n+#if PY_VERSION_HEX < 0x02020000\n+# ifndef PyExc_StopIteration\n+#  define PyExc_StopIteration PyExc_RuntimeError\n+# endif\n+# ifndef PyObject_GenericGetAttr\n+#  define PyObject_GenericGetAttr 0\n+# endif\n+#endif\n+\n+/* Py_NotImplemented is defined in 2.1 and up. */\n+#if PY_VERSION_HEX < 0x02010000\n+# ifndef Py_NotImplemented\n+#  define Py_NotImplemented PyExc_RuntimeError\n+# endif\n+#endif\n+\n+/* A crude PyString_AsStringAndSize implementation for old Pythons */\n+#if PY_VERSION_HEX < 0x02010000\n+# ifndef PyString_AsStringAndSize\n+#  define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}\n+# endif\n+#endif\n+\n+/* PySequence_Size for old Pythons */\n+#if PY_VERSION_HEX < 0x02000000\n+# ifndef PySequence_Size\n+#  define PySequence_Size PySequence_Length\n+# endif\n+#endif\n+\n+/* PyBool_FromLong for old Pythons */\n+#if PY_VERSION_HEX < 0x02030000\n+static\n+PyObject *PyBool_FromLong(long ok)\n+{\n+  PyObject *result = ok ? Py_True : Py_False;\n+  Py_INCREF(result);\n+  return result;\n+}\n+#endif\n+\n+/* Py_ssize_t for old Pythons */\n+/* This code is as recommended by: */\n+/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */\n+#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)\n+typedef int Py_ssize_t;\n+# define PY_SSIZE_T_MAX INT_MAX\n+# define PY_SSIZE_T_MIN INT_MIN\n+typedef inquiry lenfunc;\n+typedef intargfunc ssizeargfunc;\n+typedef intintargfunc ssizessizeargfunc;\n+typedef intobjargproc ssizeobjargproc;\n+typedef intintobjargproc ssizessizeobjargproc;\n+typedef getreadbufferproc readbufferproc;\n+typedef getwritebufferproc writebufferproc;\n+typedef getsegcountproc segcountproc;\n+typedef getcharbufferproc charbufferproc;\n+static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))\n+{\n+  long result = 0;\n+  PyObject *i = PyNumber_Int(x);\n+  if (i) {\n+    result = PyInt_AsLong(i);\n+    Py_DECREF(i);\n+  }\n+  return result;\n+}\n+#endif\n+\n+#if PY_VERSION_HEX < 0x02050000\n+#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)\n+#endif\n+\n+#if PY_VERSION_HEX < 0x02040000\n+#define Py_VISIT(op)\t\t\t\t\\\n+  do { \t\t\t\t\t\t\\\n+    if (op) {\t\t\t\t\t\\\n+      int vret = visit((op), arg);\t\t\\\n+      if (vret)\t\t\t\t\t\\\n+        return vret;\t\t\t\t\\\n+    }\t\t\t\t\t\t\\\n+  } while (0)\n+#endif\n+\n+#if PY_VERSION_HEX < 0x02030000\n+typedef struct {\n+  PyTypeObject type;\n+  PyNumberMethods as_number;\n+  PyMappingMethods as_mapping;\n+  PySequenceMethods as_sequence;\n+  PyBufferProcs as_buffer;\n+  PyObject *name, *slots;\n+} PyHeapTypeObject;\n+#endif\n+\n+#if PY_VERSION_HEX < 0x02030000\n+typedef destructor freefunc;\n+#endif\n+\n+#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \\\n+     (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \\\n+     (PY_MAJOR_VERSION > 3))\n+# define SWIGPY_USE_CAPSULE\n+# define SWIGPY_CAPSULE_NAME ((char*)\"swig_runtime_data\" SWIG_RUNTIME_VERSION \".type_pointer_capsule\" SWIG_TYPE_TABLE_NAME)\n+#endif\n+\n+#if PY_VERSION_HEX < 0x03020000\n+#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)\n+#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)\n+#endif\n+\n+/* -----------------------------------------------------------------------------\n+ * error manipulation\n+ * ----------------------------------------------------------------------------- */\n+\n+SWIGRUNTIME PyObject*\n+SWIG_Python_ErrorType(int code) {\n+  PyObject* type = 0;\n+  switch(code) {\n+  case SWIG_MemoryError:\n+    type = PyExc_MemoryError;\n+    break;\n+  case SWIG_IOError:\n+    type = PyExc_IOError;\n+    break;\n+  case SWIG_RuntimeError:\n+    type = PyExc_RuntimeError;\n+    break;\n+  case SWIG_IndexError:\n+    type = PyExc_IndexError;\n+    break;\n+  case SWIG_TypeError:\n+    type = PyExc_TypeError;\n+    break;\n+  case SWIG_DivisionByZero:\n+    type = PyExc_ZeroDivisionError;\n+    break;\n+  case SWIG_OverflowError:\n+    type = PyExc_OverflowError;\n+    break;\n+  case SWIG_SyntaxError:\n+    type = PyExc_SyntaxError;\n+    break;\n+  case SWIG_ValueError:\n+    type = PyExc_ValueError;\n+    break;\n+  case SWIG_SystemError:\n+    type = PyExc_SystemError;\n+    break;\n+  case SWIG_AttributeError:\n+    type = PyExc_AttributeError;\n+    break;\n+  default:\n+    type = PyExc_RuntimeError;\n+  }\n+  return type;\n+}\n+\n+\n+SWIGRUNTIME void\n+SWIG_Python_AddErrorMsg(const char* mesg)\n+{\n+  PyObject *type = 0;\n+  PyObject *value = 0;\n+  PyObject *traceback = 0;\n+\n+  if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);\n+  if (value) {\n+    char *tmp;\n+    PyObject *old_str = PyObject_Str(value);\n+    PyErr_Clear();\n+    Py_XINCREF(type);\n+\n+    PyErr_Format(type, \"%s %s\", tmp = SWIG_Python_str_AsChar(old_str), mesg);\n+    SWIG_Python_str_DelForPy3(tmp);\n+    Py_DECREF(old_str);\n+    Py_DECREF(value);\n+  } else {\n+    PyErr_SetString(PyExc_RuntimeError, mesg);\n+  }\n+}\n+\n+#if defined(SWIG_PYTHON_NO_THREADS)\n+#  if defined(SWIG_PYTHON_THREADS)\n+#    undef SWIG_PYTHON_THREADS\n+#  endif\n+#endif\n+#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */\n+#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)\n+#    if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */\n+#      define SWIG_PYTHON_USE_GIL\n+#    endif\n+#  endif\n+#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */\n+#    ifndef SWIG_PYTHON_INITIALIZE_THREADS\n+#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() \n+#    endif\n+#    ifdef __cplusplus /* C++ code */\n+       class SWIG_Python_Thread_Block {\n+         bool status;\n+         PyGILState_STATE state;\n+       public:\n+         void end() { if (status) { PyGILState_Release(state); status = false;} }\n+         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}\n+         ~SWIG_Python_Thread_Block() { end(); }\n+       };\n+       class SWIG_Python_Thread_Allow {\n+         bool status;\n+         PyThreadState *save;\n+       public:\n+         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}\n+         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}\n+         ~SWIG_Python_Thread_Allow() { end(); }\n+       };\n+#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block\n+#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()\n+#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow\n+#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()\n+#    else /* C code */\n+#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()\n+#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)\n+#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()\n+#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)\n+#    endif\n+#  else /* Old thread way, not implemented, user must provide it */\n+#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)\n+#      define SWIG_PYTHON_INITIALIZE_THREADS\n+#    endif\n+#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)\n+#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK\n+#    endif\n+#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)\n+#      define SWIG_PYTHON_THREAD_END_BLOCK\n+#    endif\n+#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)\n+#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW\n+#    endif\n+#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)\n+#      define SWIG_PYTHON_THREAD_END_ALLOW\n+#    endif\n+#  endif\n+#else /* No thread support */\n+#  define SWIG_PYTHON_INITIALIZE_THREADS\n+#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK\n+#  define SWIG_PYTHON_THREAD_END_BLOCK\n+#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW\n+#  define SWIG_PYTHON_THREAD_END_ALLOW\n+#endif\n+\n+/* -----------------------------------------------------------------------------\n+ * Python API portion that goes into the runtime\n+ * ----------------------------------------------------------------------------- */\n+\n+#ifdef __cplusplus\n+extern \"C\" {\n+#endif\n+\n+/* -----------------------------------------------------------------------------\n+ * Constant declarations\n+ * ----------------------------------------------------------------------------- */\n+\n+/* Constant Types */\n+#define SWIG_PY_POINTER 4\n+#define SWIG_PY_BINARY  5\n+\n+/* Constant information structure */\n+typedef struct swig_const_info {\n+  int type;\n+  char *name;\n+  long lvalue;\n+  double dvalue;\n+  void   *pvalue;\n+  swig_type_info **ptype;\n+} swig_const_info;\n+\n+\n+/* -----------------------------------------------------------------------------\n+ * Wrapper of PyInstanceMethod_New() used in Python 3\n+ * It is exported to the generated module, used for -fastproxy\n+ * ----------------------------------------------------------------------------- */\n+#if PY_VERSION_HEX >= 0x03000000\n+SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)\n+{\n+  return PyInstanceMethod_New(func);\n+}\n+#else\n+SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))\n+{\n+  return NULL;\n+}\n+#endif\n+\n+#ifdef __cplusplus\n+}\n+#endif\n+\n+\n+/* -----------------------------------------------------------------------------\n+ * pyrun.swg\n+ *\n+ * This file contains the runtime support for Python modules\n+ * and includes code for managing global variables and pointer\n+ * type checking.\n+ *\n+ * ----------------------------------------------------------------------------- */\n+\n+/* Common SWIG API */\n+\n+/* for raw pointers */\n+#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)\n+#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)\n+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)\n+\n+#ifdef SWIGPYTHON_BUILTIN\n+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)\n+#else\n+#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)\n+#endif\n+\n+#define SWIG_InternalNewPointerObj(ptr, type, flags)\tSWIG_Python_NewPointerObj(NULL, ptr, type, flags)\n+\n+#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) \n+#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)\n+#define swig_owntype                                    int\n+\n+/* for raw packed data */\n+#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)\n+#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)\n+\n+/* for class or struct pointers */\n+#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)\n+#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)\n+\n+/* for C or C++ function pointers */\n+#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)\n+#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)\n+\n+/* for C++ member pointers, ie, member methods */\n+#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)\n+#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)\n+\n+\n+/* Runtime API */\n+\n+#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)\n+#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)\n+#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)\n+\n+#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            \n+#define SWIG_SetErrorMsg                        \tSWIG_Python_SetErrorMsg\t\t\t\t   \n+#define SWIG_ErrorType(code)                    \tSWIG_Python_ErrorType(code)                        \n+#define SWIG_Error(code, msg)            \t\tSWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) \n+#define SWIG_fail                        \t\tgoto fail\t\t\t\t\t   \n+\n+\n+/* Runtime API implementation */\n+\n+/* Error manipulation */\n+\n+SWIGINTERN void \n+SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {\n+  SWIG_PYTHON_THREAD_BEGIN_BLOCK; \n+  PyErr_SetObject(errtype, obj);\n+  Py_DECREF(obj);\n+  SWIG_PYTHON_THREAD_END_BLOCK;\n+}\n+\n+SWIGINTERN void \n+SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {\n+  SWIG_PYTHON_THREAD_BEGIN_BLOCK;\n+  PyErr_SetString(errtype, msg);\n+  SWIG_PYTHON_THREAD_END_BLOCK;\n+}\n+\n+#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)\n+\n+/* Set a constant value */\n+\n+#if defined(SWIGPYTHON_BUILTIN)\n+\n+SWIGINTERN void\n+SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {\n+  PyObject *s = PyString_InternFromString(key);\n+  PyList_Append(seq, s);\n+  Py_DECREF(s);\n+}\n+\n+SWIGINTERN void\n+SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   \n+#if PY_VERSION_HEX < 0x02030000\n+  PyDict_SetItemString(d, (char *)name, obj);\n+#else\n+  PyDict_SetItemString(d, name, obj);\n+#endif\n+  Py_DECREF(obj);\n+  if (public_interface)\n+    SwigPyBuiltin_AddPublicSymbol(public_interface, name);\n+}\n+\n+#else\n+\n+SWIGINTERN void\n+SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   \n+#if PY_VERSION_HEX < 0x02030000\n+  PyDict_SetItemString(d, (char *)name, obj);\n+#else\n+  PyDict_SetItemString(d, name, obj);\n+#endif\n+  Py_DECREF(obj);                            \n+}\n+\n+#endif\n+\n+/* Append a value to the result obj */\n+\n+SWIGINTERN PyObject*\n+SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {\n+#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)\n+  if (!result) {\n+    result = obj;\n+  } else if (result == Py_None) {\n+    Py_DECREF(result);\n+    result = obj;\n+  } else {\n+    if (!PyList_Check(result)) {\n+      PyObject *o2 = result;\n+      result = PyList_New(1);\n+      PyList_SetItem(result, 0, o2);\n+    }\n+    PyList_Append(result,obj);\n+    Py_DECREF(obj);\n+  }\n+  return result;\n+#else\n+  PyObject*   o2;\n+  PyObject*   o3;\n+  if (!result) {\n+    result = obj;\n+  } else if (result == Py_None) {\n+    Py_DECREF(result);\n+    result = obj;\n+  } else {\n+    if (!PyTuple_Check(result)) {\n+      o2 = result;\n+      result = PyTuple_New(1);\n+      PyTuple_SET_ITEM(result, 0, o2);\n+    }\n+    o3 = PyTuple_New(1);\n+    PyTuple_SET_ITEM(o3, 0, obj);\n+    o2 = result;\n+    result = PySequence_Concat(o2, o3);\n+    Py_DECREF(o2);\n+    Py_DECREF(o3);\n+  }\n+  return result;\n+#endif\n+}\n+\n+/* Unpack the argument tuple */\n+\n+SWIGINTERN Py_ssize_t\n+SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)\n+{\n+  if (!args) {\n+    if (!min && !max) {\n+      return 1;\n+    } else {\n+      PyErr_Format(PyExc_TypeError, \"%s expected %s%d arguments, got none\", \n+\t\t   name, (min == max ? \"\" : \"at least \"), (int)min);\n+      return 0;\n+    }\n+  }  \n+  if (!PyTuple_Check(args)) {\n+    if (min <= 1 && max >= 1) {\n+      Py_ssize_t i;\n+      objs[0] = args;\n+      for (i = 1; i < max; ++i) {\n+\tobjs[i] = 0;\n+      }\n+      return 2;\n+    }\n+    PyErr_SetString(PyExc_SystemError, \"UnpackTuple() argument list is not a tuple\");\n+    return 0;\n+  } else {\n+    Py_ssize_t l = PyTuple_GET_SIZE(args);\n+    if (l < min) {\n+      PyErr_Format(PyExc_TypeError, \"%s expected %s%d arguments, got %d\", \n+\t\t   name, (min == max ? \"\" : \"at least \"), (int)min, (int)l);\n+      return 0;\n+    } else if (l > max) {\n+      PyErr_Format(PyExc_TypeError, \"%s expected %s%d arguments, got %d\", \n+\t\t   name, (min == max ? \"\" : \"at most \"), (int)max, (int)l);\n+      return 0;\n+    } else {\n+      Py_ssize_t i;\n+      for (i = 0; i < l; ++i) {\n+\tobjs[i] = PyTuple_GET_ITEM(args, i);\n+      }\n+      for (; l < max; ++l) {\n+\tobjs[l] = 0;\n+      }\n+      return i + 1;\n+    }    \n+  }\n+}\n+\n+/* A functor is a function object with one single object argument */\n+#if PY_VERSION_HEX >= 0x02020000\n+#define SWIG_Python_CallFunctor(functor, obj)\t        PyObject_CallFunctionObjArgs(functor, obj, NULL);\n+#else\n+#define SWIG_Python_CallFunctor(functor, obj)\t        PyObject_CallFunction(functor, \"O\", obj);\n+#endif\n+\n+/*\n+  Helper for static pointer initialization for both C and C++ code, for example\n+  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);\n+*/\n+#ifdef __cplusplus\n+#define SWIG_STATIC_POINTER(var)  var\n+#else\n+#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var\n+#endif\n+\n+/* -----------------------------------------------------------------------------\n+ * Pointer declarations\n+ * ----------------------------------------------------------------------------- */\n+\n+/* Flags for new pointer objects */\n+#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)\n+#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)\n+\n+#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)\n+\n+#define SWIG_BUILTIN_TP_INIT\t    (SWIG_POINTER_OWN << 2)\n+#define SWIG_BUILTIN_INIT\t    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)\n+\n+#ifdef __cplusplus\n+extern \"C\" {\n+#endif\n+\n+/*  How to access Py_None */\n+#if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)\n+#  ifndef SWIG_PYTHON_NO_BUILD_NONE\n+#    ifndef SWIG_PYTHON_BUILD_NONE\n+#      define SWIG_PYTHON_BUILD_NONE\n+#    endif\n+#  endif\n+#endif\n+\n+#ifdef SWIG_PYTHON_BUILD_NONE\n+#  ifdef Py_None\n+#   undef Py_None\n+#   define Py_None SWIG_Py_None()\n+#  endif\n+SWIGRUNTIMEINLINE PyObject * \n+_SWIG_Py_None(void)\n+{\n+  PyObject *none = Py_BuildValue((char*)\"\");\n+  Py_DECREF(none);\n+  return none;\n+}\n+SWIGRUNTIME PyObject * \n+SWIG_Py_None(void)\n+{\n+  static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();\n+  return none;\n+}\n+#endif\n+\n+/* The python void return value */\n+\n+SWIGRUNTIMEINLINE PyObject * \n+SWIG_Py_Void(void)\n+{\n+  PyObject *none = Py_None;\n+  Py_INCREF(none);\n+  return none;\n+}\n+\n+/* SwigPyClientData */\n+\n+typedef struct {\n+  PyObject *klass;\n+  PyObject *newraw;\n+  PyObject *newargs;\n+  PyObject *destroy;\n+  int delargs;\n+  int implicitconv;\n+  PyTypeObject *pytype;\n+} SwigPyClientData;\n+\n+SWIGRUNTIMEINLINE int \n+SWIG_Python_CheckImplicit(swig_type_info *ty)\n+{\n+  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;\n+  return data ? data->implicitconv : 0;\n+}\n+\n+SWIGRUNTIMEINLINE PyObject *\n+SWIG_Python_ExceptionType(swig_type_info *desc) {\n+  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;\n+  PyObject *klass = data ? data->klass : 0;\n+  return (klass ? klass : PyExc_RuntimeError);\n+}\n+\n+\n+SWIGRUNTIME SwigPyClientData * \n+SwigPyClientData_New(PyObject* obj)\n+{\n+  if (!obj) {\n+    return 0;\n+  } else {\n+    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));\n+    /* the klass element */\n+    data->klass = obj;\n+    Py_INCREF(data->klass);\n+    /* the newraw method and newargs arguments used to create a new raw instance */\n+    if (PyClass_Check(obj)) {\n+      data->newraw = 0;\n+      data->newargs = obj;\n+      Py_INCREF(obj);\n+    } else {\n+#if (PY_VERSION_HEX < 0x02020000)\n+      data->newraw = 0;\n+#else\n+      data->newraw = PyObject_GetAttrString(data->klass, (char *)\"__new__\");\n+#endif\n+      if (data->newraw) {\n+\tPy_INCREF(data->newraw);\n+\tdata->newargs = PyTuple_New(1);\n+\tPyTuple_SetItem(data->newargs, 0, obj);\n+      } else {\n+\tdata->newargs = obj;\n+      }\n+      Py_INCREF(data->newargs);\n+    }\n+    /* the destroy method, aka as the C++ delete method */\n+    data->destroy = PyObject_GetAttrString(data->klass, (char *)\"__swig_destroy__\");\n+    if (PyErr_Occurred()) {\n+      PyErr_Clear();\n+      data->destroy = 0;\n+    }\n+    if (data->destroy) {\n+      int flags;\n+      Py_INCREF(data->destroy);\n+      flags = PyCFunction_GET_FLAGS(data->destroy);\n+#ifdef METH_O\n+      data->delargs = !(flags & (METH_O));\n+#else\n+      data->delargs = 0;\n+#endif\n+    } else {\n+      data->delargs = 0;\n+    }\n+    data->implicitconv = 0;\n+    data->pytype = 0;\n+    return data;\n+  }\n+}\n+\n+SWIGRUNTIME void \n+SwigPyClientData_Del(SwigPyClientData *data) {\n+  Py_XDECREF(data->newraw);\n+  Py_XDECREF(data->newargs);\n+  Py_XDECREF(data->destroy);\n+}\n+\n+/* =============== SwigPyObject =====================*/\n+\n+typedef struct {\n+  PyObject_HEAD\n+  void *ptr;\n+  swig_type_info *ty;\n+  int own;\n+  PyObject *next;\n+#ifdef SWIGPYTHON_BUILTIN\n+  PyObject *dict;\n+#endif\n+} SwigPyObject;\n+\n+\n+#ifdef SWIGPYTHON_BUILTIN\n+\n+SWIGRUNTIME PyObject *\n+SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))\n+{\n+  SwigPyObject *sobj = (SwigPyObject *)v;\n+\n+  if (!sobj->dict)\n+    sobj->dict = PyDict_New();\n+\n+  Py_INCREF(sobj->dict);\n+  return sobj->dict;\n+}\n+\n+#endif\n+\n+SWIGRUNTIME PyObject *\n+SwigPyObject_long(SwigPyObject *v)\n+{\n+  return PyLong_FromVoidPtr(v->ptr);\n+}\n+\n+SWIGRUNTIME PyObject *\n+SwigPyObject_format(const char* fmt, SwigPyObject *v)\n+{\n+  PyObject *res = NULL;\n+  PyObject *args = PyTuple_New(1);\n+  if (args) {\n+    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {\n+      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);\n+      if (ofmt) {\n+#if PY_VERSION_HEX >= 0x03000000\n+\tres = PyUnicode_Format(ofmt,args);\n+#else\n+\tres = PyString_Format(ofmt,args);\n+#endif\n+\tPy_DECREF(ofmt);\n+      }\n+      Py_DECREF(args);\n+    }\n+  }\n+  return res;\n+}\n+\n+SWIGRUNTIME PyObject *\n+SwigPyObject_oct(SwigPyObject *v)\n+{\n+  return SwigPyObject_format(\"%o\",v);\n+}\n+\n+SWIGRUNTIME PyObject *\n+SwigPyObject_hex(SwigPyObject *v)\n+{\n+  return SwigPyObject_format(\"%x\",v);\n+}\n+\n+SWIGRUNTIME PyObject *\n+#ifdef METH_NOARGS\n+SwigPyObject_repr(SwigPyObject *v)\n+#else\n+SwigPyObject_repr(SwigPyObject *v, PyObject *args)\n+#endif\n+{\n+  const char *name = SWIG_TypePrettyName(v->ty);\n+  PyObject *repr = SWIG_Python_str_FromFormat(\"<Swig Object of type '%s' at %p>\", (name ? name : \"unknown\"), (void *)v);\n+  if (v->next) {\n+# ifdef METH_NOARGS\n+    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);\n+# else\n+    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);\n+# endif\n+# if PY_VERSION_HEX >= 0x03000000\n+    PyObject *joined = PyUnicode_Concat(repr, nrep);\n+    Py_DecRef(repr);\n+    Py_DecRef(nrep);\n+    repr = joined;\n+# else\n+    PyString_ConcatAndDel(&repr,nrep);\n+# endif\n+  }\n+  return repr;  \n+}\n+\n+SWIGRUNTIME int\n+SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)\n+{\n+  void *i = v->ptr;\n+  void *j = w->ptr;\n+  return (i < j) ? -1 : ((i > j) ? 1 : 0);\n+}\n+\n+/* Added for Python 3.x, would it also be useful for Python 2.x? */\n+SWIGRUNTIME PyObject*\n+SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)\n+{\n+  PyObject* res;\n+  if( op != Py_EQ && op != Py_NE ) {\n+    Py_INCREF(Py_NotImplemented);\n+    return Py_NotImplemented;\n+  }\n+  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);\n+  return res;  \n+}\n+\n+\n+SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);\n+\n+#ifdef SWIGPYTHON_BUILTIN\n+static swig_type_info *SwigPyObject_stype = 0;\n+SWIGRUNTIME PyTypeObject*\n+SwigPyObject_type(void) {\n+    SwigPyClientData *cd;\n+    assert(SwigPyObject_stype);\n+    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;\n+    assert(cd);\n+    assert(cd->pytype);\n+    return cd->pytype;\n+}\n+#else\n+SWIGRUNTIME PyTypeObject*\n+SwigPyObject_type(void) {\n+  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();\n+  return type;\n+}\n+#endif\n+\n+SWIGRUNTIMEINLINE int\n+SwigPyObject_Check(PyObject *op) {\n+#ifdef SWIGPYTHON_BUILTIN\n+  PyTypeObject *target_tp = SwigPyObject_type();\n+  if (PyType_IsSubtype(op->ob_type, target_tp))\n+    return 1;\n+  return (strcmp(op->ob_type->tp_name, \"SwigPyObject\") == 0);\n+#else\n+  return (Py_TYPE(op) == SwigPyObject_type())\n+    || (strcmp(Py_TYPE(op)->tp_name,\"SwigPyObject\") == 0);\n+#endif\n+}\n+\n+SWIGRUNTIME PyObject *\n+SwigPyObject_New(void *ptr, swig_type_info *ty, int own);\n+\n+SWIGRUNTIME void\n+SwigPyObject_dealloc(PyObject *v)\n+{\n+  SwigPyObject *sobj = (SwigPyObject *) v;\n+  PyObject *next = sobj->next;\n+  if (sobj->own == SWIG_POINTER_OWN) {\n+    swig_type_info *ty = sobj->ty;\n+    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;\n+    PyObject *destroy = data ? data->destroy : 0;\n+    if (destroy) {\n+      /* destroy is always a VARARGS method */\n+      PyObject *res;\n+\n+      /* PyObject_CallFunction() has the potential to silently drop\n+         the active active exception.  In cases of unnamed temporary\n+         variable or where we just finished iterating over a generator\n+         StopIteration will be active right now, and this needs to\n+         remain true upon return from SwigPyObject_dealloc.  So save\n+         and restore. */\n+      \n+      PyObject *val = NULL, *type = NULL, *tb = NULL;\n+      PyErr_Fetch(&val, &type, &tb);\n+\n+      if (data->delargs) {\n+        /* we need to create a temporary object to carry the destroy operation */\n+        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);\n+        res = SWIG_Python_CallFunctor(destroy, tmp);\n+        Py_DECREF(tmp);\n+      } else {\n+        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);\n+        PyObject *mself = PyCFunction_GET_SELF(destroy);\n+        res = ((*meth)(mself, v));\n+      }\n+      if (!res)\n+        PyErr_WriteUnraisable(destroy);\n+\n+      PyErr_Restore(val, type, tb);\n+\n+      Py_XDECREF(res);\n+    } \n+#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)\n+    else {\n+      const char *name = SWIG_TypePrettyName(ty);\n+      printf(\"swig/python detected a memory leak of type '%s', no destructor found.\\n\", (name ? name : \"unknown\"));\n+    }\n+#endif\n+  } \n+  Py_XDECREF(next);\n+  PyObject_DEL(v);\n+}\n+\n+SWIGRUNTIME PyObject* \n+SwigPyObject_append(PyObject* v, PyObject* next)\n+{\n+  SwigPyObject *sobj = (SwigPyObject *) v;\n+#ifndef METH_O\n+  PyObject *tmp = 0;\n+  if (!PyArg_ParseTuple(next,(char *)\"O:append\", &tmp)) return NULL;\n+  next = tmp;\n+#endif\n+  if (!SwigPyObject_Check(next)) {\n+    PyErr_SetString(PyExc_TypeError, \"Attempt to append a non SwigPyObject\");\n+    return NULL;\n+  }\n+  sobj->next = next;\n+  Py_INCREF(next);\n+  return SWIG_Py_Void();\n+}\n+\n+SWIGRUNTIME PyObject* \n+#ifdef METH_NOARGS\n+SwigPyObject_next(PyObject* v)\n+#else\n+SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))\n+#endif\n+{\n+  SwigPyObject *sobj = (SwigPyObject *) v;\n+  if (sobj->next) {    \n+    Py_INCREF(sobj->next);\n+    return sobj->next;\n+  } else {\n+    return SWIG_Py_Void();\n+  }\n+}\n+\n+SWIGINTERN PyObject*\n+#ifdef METH_NOARGS\n+SwigPyObject_disown(PyObject *v)\n+#else\n+SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))\n+#endif\n+{\n+  SwigPyObject *sobj = (SwigPyObject *)v;\n+  sobj->own = 0;\n+  return SWIG_Py_Void();\n+}\n+\n+SWIGINTERN PyObject*\n+#ifdef METH_NOARGS\n+SwigPyObject_acquire(PyObject *v)\n+#else\n+SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))\n+#endif\n+{\n+  SwigPyObject *sobj = (SwigPyObject *)v;\n+  sobj->own = SWIG_POINTER_OWN;\n+  return SWIG_Py_Void();\n+}\n+\n+SWIGINTERN PyObject*\n+SwigPyObject_own(PyObject *v, PyObject *args)\n+{\n+  PyObject *val = 0;\n+#if (PY_VERSION_HEX < 0x02020000)\n+  if (!PyArg_ParseTuple(args,(char *)\"|O:own\",&val))\n+#elif (PY_VERSION_HEX < 0x02050000)\n+  if (!PyArg_UnpackTuple(args, (char *)\"own\", 0, 1, &val)) \n+#else\n+  if (!PyArg_UnpackTuple(args, \"own\", 0, 1, &val)) \n+#endif\n+    {\n+      return NULL;\n+    } \n+  else\n+    {\n+      SwigPyObject *sobj = (SwigPyObject *)v;\n+      PyObject *obj = PyBool_FromLong(sobj->own);\n+      if (val) {\n+#ifdef METH_NOARGS\n+\tif (PyObject_IsTrue(val)) {\n+\t  SwigPyObject_acquire(v);\n+\t} else {\n+\t  SwigPyObject_disown(v);\n+\t}\n+#else\n+\tif (PyObject_IsTrue(val)) {\n+\t  SwigPyObject_acquire(v,args);\n+\t} else {\n+\t  SwigPyObject_disown(v,args);\n+\t}\n+#endif\n+      } \n+      return obj;\n+    }\n+}\n+\n+#ifdef METH_O\n+static PyMethodDef\n+swigobject_methods[] = {\n+  {(char *)\"disown\",  (PyCFunction)SwigPyObject_disown,  METH_NOARGS,  (char *)\"releases ownership of the pointer\"},\n+  {(char *)\"acquire\", (PyCFunction)SwigPyObject_acquire, METH_NOARGS,  (char *)\"acquires ownership of the pointer\"},\n+  {(char *)\"own\",     (PyCFunction)SwigPyObject_own,     METH_VARARGS, (char *)\"returns/sets ownership of the pointer\"},\n+  {(char *)\"append\",  (PyCFunction)SwigPyObject_append,  METH_O,       (char *)\"appends another 'this' object\"},\n+  {(char *)\"next\",    (PyCFunction)SwigPyObject_next,    METH_NOARGS,  (char *)\"returns the next 'this' object\"},\n+  {(char *)\"__repr__\",(PyCFunction)SwigPyObject_repr,    METH_NOARGS,  (char *)\"returns object representation\"},\n+  {0, 0, 0, 0}  \n+};\n+#else\n+static PyMethodDef\n+swigobject_methods[] = {\n+  {(char *)\"disown\",  (PyCFunction)SwigPyObject_disown,  METH_VARARGS,  (char *)\"releases ownership of the pointer\"},\n+  {(char *)\"acquire\", (PyCFunction)SwigPyObject_acquire, METH_VARARGS,  (char *)\"acquires ownership of the pointer\"},\n+  {(char *)\"own\",     (PyCFunction)SwigPyObject_own,     METH_VARARGS,  (char *)\"returns/sets ownership of the pointer\"},\n+  {(char *)\"append\",  (PyCFunction)SwigPyObject_append,  METH_VARARGS,  (char *)\"appends another 'this' object\"},\n+  {(char *)\"next\",    (PyCFunction)SwigPyObject_next,    METH_VARARGS,  (char *)\"returns the next 'this' object\"},\n+  {(char *)\"__repr__\",(PyCFunction)SwigPyObject_repr,   METH_VARARGS,  (char *)\"returns object representation\"},\n+  {0, 0, 0, 0}  \n+};\n+#endif\n+\n+#if PY_VERSION_HEX < 0x02020000\n+SWIGINTERN PyObject *\n+SwigPyObject_getattr(SwigPyObject *sobj,char *name)\n+{\n+  return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);\n+}\n+#endif\n+\n+SWIGRUNTIME PyTypeObject*\n+SwigPyObject_TypeOnce(void) {\n+  static char swigobject_doc[] = \"Swig object carries a C/C++ instance pointer\";\n+\n+  static PyNumberMethods SwigPyObject_as_number = {\n+    (binaryfunc)0, /*nb_add*/\n+    (binaryfunc)0, /*nb_subtract*/\n+    (binaryfunc)0, /*nb_multiply*/\n+    /* nb_divide removed in Python 3 */\n+#if PY_VERSION_HEX < 0x03000000\n+    (binaryfunc)0, /*nb_divide*/\n+#endif\n+    (binaryfunc)0, /*nb_remainder*/\n+    (binaryfunc)0, /*nb_divmod*/\n+    (ternaryfunc)0,/*nb_power*/\n+    (unaryfunc)0,  /*nb_negative*/\n+    (unaryfunc)0,  /*nb_positive*/\n+    (unaryfunc)0,  /*nb_absolute*/\n+    (inquiry)0,    /*nb_nonzero*/\n+    0,\t\t   /*nb_invert*/\n+    0,\t\t   /*nb_lshift*/\n+    0,\t\t   /*nb_rshift*/\n+    0,\t\t   /*nb_and*/\n+    0,\t\t   /*nb_xor*/\n+    0,\t\t   /*nb_or*/\n+#if PY_VERSION_HEX < 0x03000000\n+    0,   /*nb_coerce*/\n+#endif\n+    (unaryfunc)SwigPyObject_long, /*nb_int*/\n+#if PY_VERSION_HEX < 0x03000000\n+    (unaryfunc)SwigPyObject_long, /*nb_long*/\n+#else\n+    0, /*nb_reserved*/\n+#endif\n+    (unaryfunc)0,                 /*nb_float*/\n+#if PY_VERSION_HEX < 0x03000000\n+    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/\n+    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/\n+#endif\n+#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */\n+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */\n+#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */\n+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */\n+#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */\n+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */\n+#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */\n+    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */\n+#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */\n+    0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */\n+#endif\n+  };\n+\n+  static PyTypeObject swigpyobject_type;\n+  static int type_init = 0;\n+  if (!type_init) {\n+    const PyTypeObject tmp = {\n+      /* PyObject header changed in Python 3 */\n+#if PY_VERSION_HEX >= 0x03000000\n+      PyVarObject_HEAD_INIT(NULL, 0)\n+#else\n+      PyObject_HEAD_INIT(NULL)\n+      0,                                    /* ob_size */\n+#endif\n+      (char *)\"SwigPyObject\",               /* tp_name */\n+      sizeof(SwigPyObject),                 /* tp_basicsize */\n+      0,                                    /* tp_itemsize */\n+      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */\n+      0,\t\t\t\t    /* tp_print */\n+#if PY_VERSION_HEX < 0x02020000\n+      (getattrfunc)SwigPyObject_getattr,    /* tp_getattr */\n+#else\n+      (getattrfunc)0,                       /* tp_getattr */\n+#endif\n+      (setattrfunc)0,                       /* tp_setattr */\n+#if PY_VERSION_HEX >= 0x03000000\n+    0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */\n+#else\n+      (cmpfunc)SwigPyObject_compare,        /* tp_compare */\n+#endif\n+      (reprfunc)SwigPyObject_repr,          /* tp_repr */\n+      &SwigPyObject_as_number,              /* tp_as_number */\n+      0,                                    /* tp_as_sequence */\n+      0,                                    /* tp_as_mapping */\n+      (hashfunc)0,                          /* tp_hash */\n+      (ternaryfunc)0,                       /* tp_call */\n+      0,\t\t\t\t    /* tp_str */\n+      PyObject_GenericGetAttr,              /* tp_getattro */\n+      0,                                    /* tp_setattro */\n+      0,                                    /* tp_as_buffer */\n+      Py_TPFLAGS_DEFAULT,                   /* tp_flags */\n+      swigobject_doc,                       /* tp_doc */\n+      0,                                    /* tp_traverse */\n+      0,                                    /* tp_clear */\n+      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */\n+      0,                                    /* tp_weaklistoffset */\n+#if PY_VERSION_HEX >= 0x02020000\n+      0,                                    /* tp_iter */\n+      0,                                    /* tp_iternext */\n+      swigobject_methods,                   /* tp_methods */\n+      0,                                    /* tp_members */\n+      0,                                    /* tp_getset */\n+      0,                                    /* tp_base */\n+      0,                                    /* tp_dict */\n+      0,                                    /* tp_descr_get */\n+      0,                                    /* tp_descr_set */\n+      0,                                    /* tp_dictoffset */\n+      0,                                    /* tp_init */\n+      0,                                    /* tp_alloc */\n+      0,                                    /* tp_new */\n+      0,                                    /* tp_free */\n+      0,                                    /* tp_is_gc */\n+      0,                                    /* tp_bases */\n+      0,                                    /* tp_mro */\n+      0,                                    /* tp_cache */\n+      0,                                    /* tp_subclasses */\n+      0,                                    /* tp_weaklist */\n+#endif\n+#if PY_VERSION_HEX >= 0x02030000\n+      0,                                    /* tp_del */\n+#endif\n+#if PY_VERSION_HEX >= 0x02060000\n+      0,                                    /* tp_version_tag */\n+#endif\n+#if PY_VERSION_HEX >= 0x03040000\n+      0,                                    /* tp_finalize */\n+#endif\n+#ifdef COUNT_ALLOCS\n+      0,                                    /* tp_allocs */\n+      0,                                    /* tp_frees */\n+      0,                                    /* tp_maxalloc */\n+#if PY_VERSION_HEX >= 0x02050000\n+      0,                                    /* tp_prev */\n+#endif\n+      0                                     /* tp_next */\n+#endif\n+    };\n+    swigpyobject_type = tmp;\n+    type_init = 1;\n+#if PY_VERSION_HEX < 0x02020000\n+    swigpyobject_type.ob_type = &PyType_Type;\n+#else\n+    if (PyType_Ready(&swigpyobject_type) < 0)\n+      return NULL;\n+#endif\n+  }\n+  return &swigpyobject_type;\n+}\n+\n+SWIGRUNTIME PyObject *\n+SwigPyObject_New(void *ptr, swig_type_info *ty, int own)\n+{\n+  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());\n+  if (sobj) {\n+    sobj->ptr  = ptr;\n+    sobj->ty   = ty;\n+    sobj->own  = own;\n+    sobj->next = 0;\n+  }\n+  return (PyObject *)sobj;\n+}\n+\n+/* -----------------------------------------------------------------------------\n+ * Implements a simple Swig Packed type, and use it instead of string\n+ * ----------------------------------------------------------------------------- */\n+\n+typedef struct {\n+  PyObject_HEAD\n+  void *pack;\n+  swig_type_info *ty;\n+  size_t size;\n+} SwigPyPacked;\n+\n+SWIGRUNTIME int\n+SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))\n+{\n+  char result[SWIG_BUFFER_SIZE];\n+  fputs(\"<Swig Packed \", fp); \n+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {\n+    fputs(\"at \", fp); \n+    fputs(result, fp); \n+  }\n+  fputs(v->ty->name,fp); \n+  fputs(\">\", fp);\n+  return 0; \n+}\n+  \n+SWIGRUNTIME PyObject *\n+SwigPyPacked_repr(SwigPyPacked *v)\n+{\n+  char result[SWIG_BUFFER_SIZE];\n+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {\n+    return SWIG_Python_str_FromFormat(\"<Swig Packed at %s%s>\", result, v->ty->name);\n+  } else {\n+    return SWIG_Python_str_FromFormat(\"<Swig Packed %s>\", v->ty->name);\n+  }  \n+}\n+\n+SWIGRUNTIME PyObject *\n+SwigPyPacked_str(SwigPyPacked *v)\n+{\n+  char result[SWIG_BUFFER_SIZE];\n+  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){\n+    return SWIG_Python_str_FromFormat(\"%s%s\", result, v->ty->name);\n+  } else {\n+    return SWIG_Python_str_FromChar(v->ty->name);\n+  }  \n+}\n+\n+SWIGRUNTIME int\n+SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)\n+{\n+  size_t i = v->size;\n+  size_t j = w->size;\n+  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);\n+  return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);\n+}\n+\n+SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);\n+\n+SWIGRUNTIME PyTypeObject*\n+SwigPyPacked_type(void) {\n+  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();\n+  return type;\n+}\n+\n+SWIGRUNTIMEINLINE int\n+SwigPyPacked_Check(PyObject *op) {\n+  return ((op)->ob_type == SwigPyPacked_TypeOnce()) \n+    || (strcmp((op)->ob_type->tp_name,\"SwigPyPacked\") == 0);\n+}\n+\n+SWIGRUNTIME void\n+SwigPyPacked_dealloc(PyObject *v)\n+{\n+  if (SwigPyPacked_Check(v)) {\n+    SwigPyPacked *sobj = (SwigPyPacked *) v;\n+    free(sobj->pack);\n+  }\n+  PyObject_DEL(v);\n+}\n+\n+SWIGRUNTIME PyTypeObject*\n+SwigPyPacked_TypeOnce(void) {\n+  static char swigpacked_doc[] = \"Swig object carries a C/C++ instance pointer\";\n+  static PyTypeObject swigpypacked_type;\n+  static int type_init = 0;\n+  if (!type_init) {\n+    const PyTypeObject tmp = {\n+      /* PyObject header changed in Python 3 */\n+#if PY_VERSION_HEX>=0x03000000\n+      PyVarObject_HEAD_INIT(NULL, 0)\n+#else\n+      PyObject_HEAD_INIT(NULL)\n+      0,                                    /* ob_size */\n+#endif\n+      (char *)\"SwigPyPacked\",               /* tp_name */\n+      sizeof(SwigPyPacked),                 /* tp_basicsize */\n+      0,                                    /* tp_itemsize */\n+      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */\n+      (printfunc)SwigPyPacked_print,        /* tp_print */\n+      (getattrfunc)0,                       /* tp_getattr */\n+      (setattrfunc)0,                       /* tp_setattr */\n+#if PY_VERSION_HEX>=0x03000000\n+      0, /* tp_reserved in 3.0.1 */\n+#else\n+      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */\n+#endif\n+      (reprfunc)SwigPyPacked_repr,          /* tp_repr */\n+      0,                                    /* tp_as_number */\n+    ","path":"example/openpose/inference/pafprocess/pafprocess_wrap.cxx","position":null,"original_position":4568,"commit_id":"e66205558c416777163b5e393bd33a162b6e486c","original_commit_id":"e66205558c416777163b5e393bd33a162b6e486c","user":{"login":"codacy-bot","id":19940114,"node_id":"MDQ6VXNlcjE5OTQwMTE0","avatar_url":"https://avatars1.githubusercontent.com/u/19940114?v=4","gravatar_id":"","url":"https://api.github.com/users/codacy-bot","html_url":"https://github.com/codacy-bot","followers_url":"https://api.github.com/users/codacy-bot/followers","following_url":"https://api.github.com/users/codacy-bot/following{/other_user}","gists_url":"https://api.github.com/users/codacy-bot/gists{/gist_id}","starred_url":"https://api.github.com/users/codacy-bot/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/codacy-bot/subscriptions","organizations_url":"https://api.github.com/users/codacy-bot/orgs","repos_url":"https://api.github.com/users/codacy-bot/repos","events_url":"https://api.github.com/users/codacy-bot/events{/privacy}","received_events_url":"https://api.github.com/users/codacy-bot/received_events","type":"User","site_admin":false},"body":"![Codacy](https://app.codacy.com/assets/images/favicon.png) Issue found: [C-style pointer casting](https://app.codacy.com/app/tensorlayer/tensorlayer/pullRequest?prid=2045082)","created_at":"2018-08-20T13:27:47Z","updated_at":"2018-08-20T13:27:47Z","html_url":"https://github.com/tensorlayer/tensorlayer/pull/787#discussion_r211260434","pull_request_url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787","author_association":"NONE","_links":{"self":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/comments/211260434"},"html":{"href":"https://github.com/tensorlayer/tensorlayer/pull/787#discussion_r211260434"},"pull_request":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787"}}},"pull_request":{"url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787","id":208414960,"node_id":"MDExOlB1bGxSZXF1ZXN0MjA4NDE0OTYw","html_url":"https://github.com/tensorlayer/tensorlayer/pull/787","diff_url":"https://github.com/tensorlayer/tensorlayer/pull/787.diff","patch_url":"https://github.com/tensorlayer/tensorlayer/pull/787.patch","issue_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/787","number":787,"state":"open","locked":false,"title":"[WIP] openpose example","user":{"login":"zsdonghao","id":10713581,"node_id":"MDQ6VXNlcjEwNzEzNTgx","avatar_url":"https://avatars0.githubusercontent.com/u/10713581?v=4","gravatar_id":"","url":"https://api.github.com/users/zsdonghao","html_url":"https://github.com/zsdonghao","followers_url":"https://api.github.com/users/zsdonghao/followers","following_url":"https://api.github.com/users/zsdonghao/following{/other_user}","gists_url":"https://api.github.com/users/zsdonghao/gists{/gist_id}","starred_url":"https://api.github.com/users/zsdonghao/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/zsdonghao/subscriptions","organizations_url":"https://api.github.com/users/zsdonghao/orgs","repos_url":"https://api.github.com/users/zsdonghao/repos","events_url":"https://api.github.com/users/zsdonghao/events{/privacy}","received_events_url":"https://api.github.com/users/zsdonghao/received_events","type":"User","site_admin":false},"body":"This is the TensorFlow implementation of [\"Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields\"](https://arxiv.org/pdf/1611.08050.pdf)\r\n\r\nThere are some extra works need to be done before we can merge this PR.\r\n- [ ] APIs for evaluation\r\n- [ ] APIs for deployment (TensorRT)\r\n- [ ] Provides pre-trained model here: https://github.com/tensorlayer/pretrained-models/tree/master/models\r\n- [ ] Provides AP results of the pre-trained model\r\n- [x] Moves (numpy-based, non-TF) data augmentation APIs into `tl.prepro`.\r\n- [ ] Moves COCO dataset download and preprocess code into `tl.files` that allow users to automatically download and prepare the dataset.\r\n- [ ] Readme:\r\n    - [x] introduction of this project\r\n    - [ ] how to use your pre-trained model\r\n    - [x] how to download dataset\r\n    - [ ] how to train and evaluate model\r\n    - [ ] how to train model on customised dataset\r\n    - [ ] how to customise data augmentation\r\n\r\nTo speed up the inferencing:\r\n- [x] For pose-processing, uses the C implementation of OpenPose\r\n- [ ] Smaller model\r\n- [ ] TensorRT float16 (half-float) inferencing\r\n\r\nFor TensorLayer Project Quality:\r\n- [ ] Update Changelog.md\r\n- [ ] Add unittests","created_at":"2018-08-14T21:24:27Z","updated_at":"2018-08-20T13:27:47Z","closed_at":null,"merged_at":null,"merge_commit_sha":"f15085812e92cc2b7f7d02df71b4fd8f96319671","assignee":null,"assignees":[],"requested_reviewers":[{"login":"luomai","id":1136455,"node_id":"MDQ6VXNlcjExMzY0NTU=","avatar_url":"https://avatars3.githubusercontent.com/u/1136455?v=4","gravatar_id":"","url":"https://api.github.com/users/luomai","html_url":"https://github.com/luomai","followers_url":"https://api.github.com/users/luomai/followers","following_url":"https://api.github.com/users/luomai/following{/other_user}","gists_url":"https://api.github.com/users/luomai/gists{/gist_id}","starred_url":"https://api.github.com/users/luomai/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/luomai/subscriptions","organizations_url":"https://api.github.com/users/luomai/orgs","repos_url":"https://api.github.com/users/luomai/repos","events_url":"https://api.github.com/users/luomai/events{/privacy}","received_events_url":"https://api.github.com/users/luomai/received_events","type":"User","site_admin":false},{"login":"boldjoel","id":15371409,"node_id":"MDQ6VXNlcjE1MzcxNDA5","avatar_url":"https://avatars3.githubusercontent.com/u/15371409?v=4","gravatar_id":"","url":"https://api.github.com/users/boldjoel","html_url":"https://github.com/boldjoel","followers_url":"https://api.github.com/users/boldjoel/followers","following_url":"https://api.github.com/users/boldjoel/following{/other_user}","gists_url":"https://api.github.com/users/boldjoel/gists{/gist_id}","starred_url":"https://api.github.com/users/boldjoel/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/boldjoel/subscriptions","organizations_url":"https://api.github.com/users/boldjoel/orgs","repos_url":"https://api.github.com/users/boldjoel/repos","events_url":"https://api.github.com/users/boldjoel/events{/privacy}","received_events_url":"https://api.github.com/users/boldjoel/received_events","type":"User","site_admin":false}],"requested_teams":[],"labels":[],"milestone":null,"commits_url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787/commits","review_comments_url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787/comments","review_comment_url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/comments{/number}","comments_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/787/comments","statuses_url":"https://api.github.com/repos/tensorlayer/tensorlayer/statuses/e66205558c416777163b5e393bd33a162b6e486c","head":{"label":"tensorlayer:openpose","ref":"openpose","sha":"e66205558c416777163b5e393bd33a162b6e486c","user":{"login":"tensorlayer","id":32261543,"node_id":"MDEyOk9yZ2FuaXphdGlvbjMyMjYxNTQz","avatar_url":"https://avatars1.githubusercontent.com/u/32261543?v=4","gravatar_id":"","url":"https://api.github.com/users/tensorlayer","html_url":"https://github.com/tensorlayer","followers_url":"https://api.github.com/users/tensorlayer/followers","following_url":"https://api.github.com/users/tensorlayer/following{/other_user}","gists_url":"https://api.github.com/users/tensorlayer/gists{/gist_id}","starred_url":"https://api.github.com/users/tensorlayer/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/tensorlayer/subscriptions","organizations_url":"https://api.github.com/users/tensorlayer/orgs","repos_url":"https://api.github.com/users/tensorlayer/repos","events_url":"https://api.github.com/users/tensorlayer/events{/privacy}","received_events_url":"https://api.github.com/users/tensorlayer/received_events","type":"Organization","site_admin":false},"repo":{"id":60626727,"node_id":"MDEwOlJlcG9zaXRvcnk2MDYyNjcyNw==","name":"tensorlayer","full_name":"tensorlayer/tensorlayer","owner":{"login":"tensorlayer","id":32261543,"node_id":"MDEyOk9yZ2FuaXphdGlvbjMyMjYxNTQz","avatar_url":"https://avatars1.githubusercontent.com/u/32261543?v=4","gravatar_id":"","url":"https://api.github.com/users/tensorlayer","html_url":"https://github.com/tensorlayer","followers_url":"https://api.github.com/users/tensorlayer/followers","following_url":"https://api.github.com/users/tensorlayer/following{/other_user}","gists_url":"https://api.github.com/users/tensorlayer/gists{/gist_id}","starred_url":"https://api.github.com/users/tensorlayer/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/tensorlayer/subscriptions","organizations_url":"https://api.github.com/users/tensorlayer/orgs","repos_url":"https://api.github.com/users/tensorlayer/repos","events_url":"https://api.github.com/users/tensorlayer/events{/privacy}","received_events_url":"https://api.github.com/users/tensorlayer/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/tensorlayer/tensorlayer","description":"Versatile Deep Learning Toolbox","fork":false,"url":"https://api.github.com/repos/tensorlayer/tensorlayer","forks_url":"https://api.github.com/repos/tensorlayer/tensorlayer/forks","keys_url":"https://api.github.com/repos/tensorlayer/tensorlayer/keys{/key_id}","collaborators_url":"https://api.github.com/repos/tensorlayer/tensorlayer/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/tensorlayer/tensorlayer/teams","hooks_url":"https://api.github.com/repos/tensorlayer/tensorlayer/hooks","issue_events_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/events{/number}","events_url":"https://api.github.com/repos/tensorlayer/tensorlayer/events","assignees_url":"https://api.github.com/repos/tensorlayer/tensorlayer/assignees{/user}","branches_url":"https://api.github.com/repos/tensorlayer/tensorlayer/branches{/branch}","tags_url":"https://api.github.com/repos/tensorlayer/tensorlayer/tags","blobs_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/refs{/sha}","trees_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/trees{/sha}","statuses_url":"https://api.github.com/repos/tensorlayer/tensorlayer/statuses/{sha}","languages_url":"https://api.github.com/repos/tensorlayer/tensorlayer/languages","stargazers_url":"https://api.github.com/repos/tensorlayer/tensorlayer/stargazers","contributors_url":"https://api.github.com/repos/tensorlayer/tensorlayer/contributors","subscribers_url":"https://api.github.com/repos/tensorlayer/tensorlayer/subscribers","subscription_url":"https://api.github.com/repos/tensorlayer/tensorlayer/subscription","commits_url":"https://api.github.com/repos/tensorlayer/tensorlayer/commits{/sha}","git_commits_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/commits{/sha}","comments_url":"https://api.github.com/repos/tensorlayer/tensorlayer/comments{/number}","issue_comment_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/comments{/number}","contents_url":"https://api.github.com/repos/tensorlayer/tensorlayer/contents/{+path}","compare_url":"https://api.github.com/repos/tensorlayer/tensorlayer/compare/{base}...{head}","merges_url":"https://api.github.com/repos/tensorlayer/tensorlayer/merges","archive_url":"https://api.github.com/repos/tensorlayer/tensorlayer/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/tensorlayer/tensorlayer/downloads","issues_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues{/number}","pulls_url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls{/number}","milestones_url":"https://api.github.com/repos/tensorlayer/tensorlayer/milestones{/number}","notifications_url":"https://api.github.com/repos/tensorlayer/tensorlayer/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/tensorlayer/tensorlayer/labels{/name}","releases_url":"https://api.github.com/repos/tensorlayer/tensorlayer/releases{/id}","deployments_url":"https://api.github.com/repos/tensorlayer/tensorlayer/deployments","created_at":"2016-06-07T15:55:16Z","updated_at":"2018-08-20T11:39:15Z","pushed_at":"2018-08-20T13:23:18Z","git_url":"git://github.com/tensorlayer/tensorlayer.git","ssh_url":"git@github.com:tensorlayer/tensorlayer.git","clone_url":"https://github.com/tensorlayer/tensorlayer.git","svn_url":"https://github.com/tensorlayer/tensorlayer","homepage":"http://tensorlayer.readthedocs.io","size":50817,"stargazers_count":4170,"watchers_count":4170,"language":"Python","has_issues":true,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":1029,"mirror_url":null,"archived":false,"open_issues_count":50,"license":{"key":"apache-2.0","name":"Apache License 2.0","spdx_id":"Apache-2.0","url":"https://api.github.com/licenses/apache-2.0","node_id":"MDc6TGljZW5zZTI="},"forks":1029,"open_issues":50,"watchers":4170,"default_branch":"master"}},"base":{"label":"tensorlayer:master","ref":"master","sha":"4db71bc8fd25a6f21e1a825023c6e6371143c010","user":{"login":"tensorlayer","id":32261543,"node_id":"MDEyOk9yZ2FuaXphdGlvbjMyMjYxNTQz","avatar_url":"https://avatars1.githubusercontent.com/u/32261543?v=4","gravatar_id":"","url":"https://api.github.com/users/tensorlayer","html_url":"https://github.com/tensorlayer","followers_url":"https://api.github.com/users/tensorlayer/followers","following_url":"https://api.github.com/users/tensorlayer/following{/other_user}","gists_url":"https://api.github.com/users/tensorlayer/gists{/gist_id}","starred_url":"https://api.github.com/users/tensorlayer/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/tensorlayer/subscriptions","organizations_url":"https://api.github.com/users/tensorlayer/orgs","repos_url":"https://api.github.com/users/tensorlayer/repos","events_url":"https://api.github.com/users/tensorlayer/events{/privacy}","received_events_url":"https://api.github.com/users/tensorlayer/received_events","type":"Organization","site_admin":false},"repo":{"id":60626727,"node_id":"MDEwOlJlcG9zaXRvcnk2MDYyNjcyNw==","name":"tensorlayer","full_name":"tensorlayer/tensorlayer","owner":{"login":"tensorlayer","id":32261543,"node_id":"MDEyOk9yZ2FuaXphdGlvbjMyMjYxNTQz","avatar_url":"https://avatars1.githubusercontent.com/u/32261543?v=4","gravatar_id":"","url":"https://api.github.com/users/tensorlayer","html_url":"https://github.com/tensorlayer","followers_url":"https://api.github.com/users/tensorlayer/followers","following_url":"https://api.github.com/users/tensorlayer/following{/other_user}","gists_url":"https://api.github.com/users/tensorlayer/gists{/gist_id}","starred_url":"https://api.github.com/users/tensorlayer/starred{/owner}{/repo}","subscriptions_url":"https://api.github.com/users/tensorlayer/subscriptions","organizations_url":"https://api.github.com/users/tensorlayer/orgs","repos_url":"https://api.github.com/users/tensorlayer/repos","events_url":"https://api.github.com/users/tensorlayer/events{/privacy}","received_events_url":"https://api.github.com/users/tensorlayer/received_events","type":"Organization","site_admin":false},"private":false,"html_url":"https://github.com/tensorlayer/tensorlayer","description":"Versatile Deep Learning Toolbox","fork":false,"url":"https://api.github.com/repos/tensorlayer/tensorlayer","forks_url":"https://api.github.com/repos/tensorlayer/tensorlayer/forks","keys_url":"https://api.github.com/repos/tensorlayer/tensorlayer/keys{/key_id}","collaborators_url":"https://api.github.com/repos/tensorlayer/tensorlayer/collaborators{/collaborator}","teams_url":"https://api.github.com/repos/tensorlayer/tensorlayer/teams","hooks_url":"https://api.github.com/repos/tensorlayer/tensorlayer/hooks","issue_events_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/events{/number}","events_url":"https://api.github.com/repos/tensorlayer/tensorlayer/events","assignees_url":"https://api.github.com/repos/tensorlayer/tensorlayer/assignees{/user}","branches_url":"https://api.github.com/repos/tensorlayer/tensorlayer/branches{/branch}","tags_url":"https://api.github.com/repos/tensorlayer/tensorlayer/tags","blobs_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/blobs{/sha}","git_tags_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/tags{/sha}","git_refs_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/refs{/sha}","trees_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/trees{/sha}","statuses_url":"https://api.github.com/repos/tensorlayer/tensorlayer/statuses/{sha}","languages_url":"https://api.github.com/repos/tensorlayer/tensorlayer/languages","stargazers_url":"https://api.github.com/repos/tensorlayer/tensorlayer/stargazers","contributors_url":"https://api.github.com/repos/tensorlayer/tensorlayer/contributors","subscribers_url":"https://api.github.com/repos/tensorlayer/tensorlayer/subscribers","subscription_url":"https://api.github.com/repos/tensorlayer/tensorlayer/subscription","commits_url":"https://api.github.com/repos/tensorlayer/tensorlayer/commits{/sha}","git_commits_url":"https://api.github.com/repos/tensorlayer/tensorlayer/git/commits{/sha}","comments_url":"https://api.github.com/repos/tensorlayer/tensorlayer/comments{/number}","issue_comment_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/comments{/number}","contents_url":"https://api.github.com/repos/tensorlayer/tensorlayer/contents/{+path}","compare_url":"https://api.github.com/repos/tensorlayer/tensorlayer/compare/{base}...{head}","merges_url":"https://api.github.com/repos/tensorlayer/tensorlayer/merges","archive_url":"https://api.github.com/repos/tensorlayer/tensorlayer/{archive_format}{/ref}","downloads_url":"https://api.github.com/repos/tensorlayer/tensorlayer/downloads","issues_url":"https://api.github.com/repos/tensorlayer/tensorlayer/issues{/number}","pulls_url":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls{/number}","milestones_url":"https://api.github.com/repos/tensorlayer/tensorlayer/milestones{/number}","notifications_url":"https://api.github.com/repos/tensorlayer/tensorlayer/notifications{?since,all,participating}","labels_url":"https://api.github.com/repos/tensorlayer/tensorlayer/labels{/name}","releases_url":"https://api.github.com/repos/tensorlayer/tensorlayer/releases{/id}","deployments_url":"https://api.github.com/repos/tensorlayer/tensorlayer/deployments","created_at":"2016-06-07T15:55:16Z","updated_at":"2018-08-20T11:39:15Z","pushed_at":"2018-08-20T13:23:18Z","git_url":"git://github.com/tensorlayer/tensorlayer.git","ssh_url":"git@github.com:tensorlayer/tensorlayer.git","clone_url":"https://github.com/tensorlayer/tensorlayer.git","svn_url":"https://github.com/tensorlayer/tensorlayer","homepage":"http://tensorlayer.readthedocs.io","size":50817,"stargazers_count":4170,"watchers_count":4170,"language":"Python","has_issues":true,"has_projects":true,"has_downloads":true,"has_wiki":true,"has_pages":false,"forks_count":1029,"mirror_url":null,"archived":false,"open_issues_count":50,"license":{"key":"apache-2.0","name":"Apache License 2.0","spdx_id":"Apache-2.0","url":"https://api.github.com/licenses/apache-2.0","node_id":"MDc6TGljZW5zZTI="},"forks":1029,"open_issues":50,"watchers":4170,"default_branch":"master"}},"_links":{"self":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787"},"html":{"href":"https://github.com/tensorlayer/tensorlayer/pull/787"},"issue":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/787"},"comments":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/issues/787/comments"},"review_comments":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787/comments"},"review_comment":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/comments{/number}"},"commits":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/pulls/787/commits"},"statuses":{"href":"https://api.github.com/repos/tensorlayer/tensorlayer/statuses/e66205558c416777163b5e393bd33a162b6e486c"}},"author_association":"MEMBER"}}
{"actor":{"display_login":"codacy-bot"}}