#define SWIGPYTHON

#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#ifndef SWIGTEMPLATEDISAMBIGUATOR

# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)

# define SWIGTEMPLATEDISAMBIGUATOR template

# elif defined(__HP_aCC)

# define SWIGTEMPLATEDISAMBIGUATOR template

# define SWIGTEMPLATEDISAMBIGUATOR

#ifndef SWIGINLINE

# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))

# define SWIGINLINE inline

# define SWIGINLINE

#ifndef SWIGUNUSED

# if defined(__GNUC__)

# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

# define SWIGUNUSED __attribute__ ((__unused__))

# define SWIGUNUSED

# elif defined(__ICC)

# define SWIGUNUSED __attribute__ ((__unused__))

# define SWIGUNUSED

#ifndef SWIG_MSC_UNSUPPRESS_4505

# if defined(_MSC_VER)

# pragma warning(disable : 4505) /* unreferenced local function has been removed */

#ifndef SWIGUNUSEDPARM

# ifdef __cplusplus

# define SWIGUNUSEDPARM(p)

# define SWIGUNUSEDPARM(p) p SWIGUNUSED

#ifndef SWIGINTERN

# define SWIGINTERN static SWIGUNUSED

#ifndef SWIGINTERNINLINE

# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE

#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)

# ifndef GCC_HASCLASSVISIBILITY

# define GCC_HASCLASSVISIBILITY

#ifndef SWIGEXPORT

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

# if defined(STATIC_LINKED)

# define SWIGEXPORT

# define SWIGEXPORT __declspec(dllexport)

# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)

# define SWIGEXPORT __attribute__ ((visibility("default")))

# define SWIGEXPORT

#ifndef SWIGSTDCALL

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

# define SWIGSTDCALL __stdcall

# define SWIGSTDCALL

#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)

# define _CRT_SECURE_NO_DEPRECATE

#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)

# define _SCL_SECURE_NO_DEPRECATE

#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)

# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0

#ifdef __INTEL_COMPILER

# pragma warning disable 592

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)

# undef _DEBUG

# include <Python.h>

# define _DEBUG

# include <Python.h>

#define SWIG_RUNTIME_VERSION "4"

#ifdef SWIG_TYPE_TABLE

# define SWIG_QUOTE_STRING(x) #x

# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)

# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)

# define SWIG_TYPE_TABLE_NAME

#ifndef SWIGRUNTIME

# define SWIGRUNTIME SWIGINTERN

#ifndef SWIGRUNTIMEINLINE

# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE

#ifndef SWIG_BUFFER_SIZE

# define SWIG_BUFFER_SIZE 1024

#define SWIG_POINTER_DISOWN 0x1

#define SWIG_CAST_NEW_MEMORY 0x2

#define SWIG_POINTER_OWN 0x1

#define SWIG_OK (0)

#define SWIG_ERROR (-1)

#define SWIG_IsOK(r) (r >= 0)

#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)

#define SWIG_CASTRANKLIMIT (1 << 8)

#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)

#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)

#define SWIG_BADOBJ (SWIG_ERROR)

#define SWIG_OLDOBJ (SWIG_OK)

#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)

#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)

#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)

#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)

#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))

#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)

#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)

#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

#if defined(SWIG_CASTRANK_MODE)

# ifndef SWIG_TypeRank

# define SWIG_TypeRank unsigned long

# ifndef SWIG_MAXCASTRANK /* Default cast allowed */

# define SWIG_MAXCASTRANK (2)

# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)

# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)

SWIGINTERNINLINE int SWIG_AddCast(int r) {

return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;

}

SWIGINTERNINLINE int SWIG_CheckState(int r) {

return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;

}

#else /* no cast-rank mode */

# define SWIG_AddCast(r) (r)

# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)

#include <string.h>

#ifdef __cplusplus

extern "C" {

typedef void *(*swig_converter_func)(void *, int *);

typedef struct swig_type_info *(*swig_dycast_func)(void **);

typedef struct swig_type_info {

} swig_type_info;

typedef struct swig_cast_info {

} swig_cast_info;

typedef struct swig_module_info {

} swig_module_info;

SWIGRUNTIME int

SWIG_TypeNameComp(const char *f1, const char *l1,

const char *f2, const char *l2) {

for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {

while ((*f1 == ' ') && (f1 != l1)) ++f1;

while ((*f2 == ' ') && (f2 != l2)) ++f2;

if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;

}

return (int)((l1 - f1) - (l2 - f2));

}

SWIGRUNTIME int

SWIG_TypeCmp(const char *nb, const char *tb) {

int equiv = 1;

const char* te = tb + strlen(tb);

const char* ne = nb;

while (equiv != 0 && *ne) {

for (nb = ne; *ne; ++ne) {

if (*ne == '|') break;

}

equiv = SWIG_TypeNameComp(nb, ne, tb, te);

if (*ne) ++ne;

}

return equiv;

}

SWIGRUNTIME int

SWIG_TypeEquiv(const char *nb, const char *tb) {

return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;

}

SWIGRUNTIME swig_cast_info *

SWIG_TypeCheck(const char *c, swig_type_info *ty) {

if (ty) {

swig_cast_info *iter = ty->cast;

while (iter) {

if (strcmp(iter->type->name, c) == 0) {

if (iter == ty->cast)

return iter;

/* Move iter to the top of the linked list */

iter->prev->next = iter->next;

if (iter->next)

iter->next->prev = iter->prev;

iter->next = ty->cast;

iter->prev = 0;

if (ty->cast) ty->cast->prev = iter;

ty->cast = iter;

return iter;

}

iter = iter->next;

}

}

return 0;

}

SWIGRUNTIME swig_cast_info *

SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {

if (ty) {

swig_cast_info *iter = ty->cast;

while (iter) {

if (iter->type == from) {

if (iter == ty->cast)

return iter;

/* Move iter to the top of the linked list */

iter->prev->next = iter->next;

if (iter->next)

iter->next->prev = iter->prev;

iter->next = ty->cast;

iter->prev = 0;

if (ty->cast) ty->cast->prev = iter;

ty->cast = iter;

return iter;

}

iter = iter->next;

}

}

return 0;

}

SWIGRUNTIMEINLINE void *

SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {

return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);

}

SWIGRUNTIME swig_type_info *

SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {

swig_type_info *lastty = ty;

if (!ty || !ty->dcast) return ty;

while (ty && (ty->dcast)) {

ty = (*ty->dcast)(ptr);

if (ty) lastty = ty;

}

return lastty;

}

SWIGRUNTIMEINLINE const char *

SWIG_TypeName(const swig_type_info *ty) {

return ty->name;

}

SWIGRUNTIME const char *

SWIG_TypePrettyName(const swig_type_info *type) {

/* The "str" field contains the equivalent pretty names of the

if (!type) return NULL;

if (type->str != NULL) {

const char *last_name = type->str;

const char *s;

for (s = type->str; *s; s++)

if (*s == '|') last_name = s+1;

return last_name;

}

else

return type->name;

}

SWIGRUNTIME void

SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {

swig_cast_info *cast = ti->cast;

/* if (ti->clientdata == clientdata) return; */

ti->clientdata = clientdata;

while (cast) {

if (!cast->converter) {

swig_type_info *tc = cast->type;

if (!tc->clientdata) {

SWIG_TypeClientData(tc, clientdata);

}

}

cast = cast->next;

}

}

SWIGRUNTIME void

SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {

SWIG_TypeClientData(ti, clientdata);

ti->owndata = 1;

}

SWIGRUNTIME swig_type_info *

SWIG_MangledTypeQueryModule(swig_module_info *start,

swig_module_info *end,

const char *name) {

swig_module_info *iter = start;

do {

if (iter->size) {

size_t l = 0;

size_t r = iter->size - 1;

do {

/* since l+r >= 0, we can (>> 1) instead (/ 2) */

size_t i = (l + r) >> 1;

const char *iname = iter->types[i]->name;

if (iname) {

int compare = strcmp(name, iname);

if (compare == 0) {

return iter->types[i];

} else if (compare < 0) {

if (i) {

r = i - 1;

} else {

break;

}

} else if (compare > 0) {

l = i + 1;

}

} else {

break; /* should never happen */

}

} while (l <= r);

}

iter = iter->next;

} while (iter != end);

return 0;

}

SWIGRUNTIME swig_type_info *

SWIG_TypeQueryModule(swig_module_info *start,

swig_module_info *end,

const char *name) {

/* STEP 1: Search the name field using binary search */

swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);

if (ret) {

return ret;

} else {

/* STEP 2: If the type hasn't been found, do a complete search

swig_module_info *iter = start;

do {

size_t i = 0;

for (; i < iter->size; ++i) {

if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))

return iter->types[i];

}

iter = iter->next;

} while (iter != end);

}

/* neither found a match */

return 0;

}

SWIGRUNTIME char *

SWIG_PackData(char *c, void *ptr, size_t sz) {

static const char hex[17] = "0123456789abcdef";

const unsigned char *u = (unsigned char *) ptr;

const unsigned char *eu = u + sz;

for (; u != eu; ++u) {

unsigned char uu = *u;

*(c++) = hex[(uu & 0xf0) >> 4];

*(c++) = hex[uu & 0xf];

}

return c;

}

SWIGRUNTIME const char *

SWIG_UnpackData(const char *c, void *ptr, size_t sz) {

unsigned char *u = (unsigned char *) ptr;

const unsigned char *eu = u + sz;

for (; u != eu; ++u) {

char d = *(c++);

unsigned char uu;

if ((d >= '0') && (d <= '9'))

uu = ((d - '0') << 4);

else if ((d >= 'a') && (d <= 'f'))

uu = ((d - ('a'-10)) << 4);

else

return (char *) 0;

d = *(c++);

if ((d >= '0') && (d <= '9'))

uu |= (d - '0');

else if ((d >= 'a') && (d <= 'f'))

uu |= (d - ('a'-10));

else

return (char *) 0;

*u = uu;

}

return c;

}

SWIGRUNTIME char *

SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {

char *r = buff;

if ((2*sizeof(void *) + 2) > bsz) return 0;

*(r++) = '_';

r = SWIG_PackData(r,&ptr,sizeof(void *));

if (strlen(name) + 1 > (bsz - (r - buff))) return 0;

strcpy(r,name);

return buff;

}

SWIGRUNTIME const char *

SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {

if (*c != '_') {

if (strcmp(c,"NULL") == 0) {

*ptr = (void *) 0;

return name;

} else {

return 0;

}

}

return SWIG_UnpackData(++c,ptr,sizeof(void *));

}

SWIGRUNTIME char *

SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {

char *r = buff;

size_t lname = (name ? strlen(name) : 0);

if ((2*sz + 2 + lname) > bsz) return 0;

*(r++) = '_';

r = SWIG_PackData(r,ptr,sz);

if (lname) {

strncpy(r,name,lname+1);

} else {

*r = 0;

}

return buff;

}

SWIGRUNTIME const char *

SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {

if (*c != '_') {

if (strcmp(c,"NULL") == 0) {

memset(ptr,0,sz);

return name;

} else {

return 0;

}

}

return SWIG_UnpackData(++c,ptr,sz);

}

#ifdef __cplusplus

}

#define SWIG_UnknownError -1

#define SWIG_IOError -2

#define SWIG_RuntimeError -3

#define SWIG_IndexError -4

#define SWIG_TypeError -5

#define SWIG_DivisionByZero -6

#define SWIG_OverflowError -7

#define SWIG_SyntaxError -8

#define SWIG_ValueError -9

#define SWIG_SystemError -10

#define SWIG_AttributeError -11

#define SWIG_MemoryError -12

#define SWIG_NullReferenceError -13

#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)

#define PyInt_Check(x) PyLong_Check(x)

#define PyInt_AsLong(x) PyLong_AsLong(x)

#define PyInt_FromLong(x) PyLong_FromLong(x)

#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)

#define PyString_Check(name) PyBytes_Check(name)

#define PyString_FromString(x) PyUnicode_FromString(x)

#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)

#define PyString_AsString(str) PyBytes_AsString(str)

#define PyString_Size(str) PyBytes_Size(str)

#define PyString_InternFromString(key) PyUnicode_InternFromString(key)

#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE

#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)

#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#ifndef Py_TYPE

# define Py_TYPE(op) ((op)->ob_type)

#if PY_VERSION_HEX >= 0x03000000

# define SWIG_Python_str_FromFormat PyUnicode_FromFormat

# define SWIG_Python_str_FromFormat PyString_FromFormat

SWIGINTERN char*

SWIG_Python_str_AsChar(PyObject *str)

{

#if PY_VERSION_HEX >= 0x03000000

char *cstr;

char *newstr;

Py_ssize_t len;

str = PyUnicode_AsUTF8String(str);

PyBytes_AsStringAndSize(str, &cstr, &len);

newstr = (char *) malloc(len+1);

memcpy(newstr, cstr, len+1);

Py_XDECREF(str);

return newstr;

return PyString_AsString(str);

}

#if PY_VERSION_HEX >= 0x03000000

# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )

# define SWIG_Python_str_DelForPy3(x)

#endif

SWIGINTERN PyObject*

SWIG_Python_str_FromChar(const char *c)

{

#if PY_VERSION_HEX >= 0x03000000

return PyUnicode_FromString(c);

return PyString_FromString(c);

}

#if PY_VERSION_HEX < 0x02020000

# if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)

# define PyOS_snprintf _snprintf

# define PyOS_snprintf snprintf

#if PY_VERSION_HEX < 0x02020000

#ifndef SWIG_PYBUFFER_SIZE

# define SWIG_PYBUFFER_SIZE 1024

static PyObject *

PyString_FromFormat(const char *fmt, ...) {

va_list ap;

char buf[SWIG_PYBUFFER_SIZE * 2];

int res;

va_start(ap, fmt);

res = vsnprintf(buf, sizeof(buf), fmt, ap);

va_end(ap);

return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);

}

#if PY_VERSION_HEX < 0x01060000

# define PyObject_Del(op) PyMem_DEL((op))

#ifndef PyObject_DEL

# define PyObject_DEL PyObject_Del

#if PY_VERSION_HEX < 0x02020000

# ifndef PyExc_StopIteration

# define PyExc_StopIteration PyExc_RuntimeError

# ifndef PyObject_GenericGetAttr

# define PyObject_GenericGetAttr 0

#if PY_VERSION_HEX < 0x02010000

# ifndef Py_NotImplemented

# define Py_NotImplemented PyExc_RuntimeError

#if PY_VERSION_HEX < 0x02010000

# ifndef PyString_AsStringAndSize

# define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}

#if PY_VERSION_HEX < 0x02000000

# ifndef PySequence_Size

# define PySequence_Size PySequence_Length

#if PY_VERSION_HEX < 0x02030000

PyObject *PyBool_FromLong(long ok)

{

PyObject *result = ok ? Py_True : Py_False;

Py_INCREF(result);

return result;

}

#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)

typedef int Py_ssize_t;

# define PY_SSIZE_T_MAX INT_MAX

# define PY_SSIZE_T_MIN INT_MIN

typedef inquiry lenfunc;

typedef intargfunc ssizeargfunc;

typedef intintargfunc ssizessizeargfunc;

typedef intobjargproc ssizeobjargproc;

typedef intintobjargproc ssizessizeobjargproc;

typedef getreadbufferproc readbufferproc;

typedef getwritebufferproc writebufferproc;

typedef getsegcountproc segcountproc;

typedef getcharbufferproc charbufferproc;

static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))

{

long result = 0;

PyObject *i = PyNumber_Int(x);

if (i) {

result = PyInt_AsLong(i);

Py_DECREF(i);

}

return result;

}

#if PY_VERSION_HEX < 0x02050000

#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)

#if PY_VERSION_HEX < 0x02040000

#define Py_VISIT(op) \

do { \

if (op) { \

int vret = visit((op), arg); \

if (vret) \

return vret; \

} \

} while (0)

#if PY_VERSION_HEX < 0x02030000

typedef struct {

PyTypeObject type;

PyNumberMethods as_number;

PyMappingMethods as_mapping;

PySequenceMethods as_sequence;

PyBufferProcs as_buffer;

PyObject *name, *slots;

} PyHeapTypeObject;

#if PY_VERSION_HEX < 0x02030000

typedef destructor freefunc;

#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \

(PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \

(PY_MAJOR_VERSION > 3))

# define SWIGPY_USE_CAPSULE

# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)

#if PY_VERSION_HEX < 0x03020000

#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)

#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)

SWIGRUNTIME PyObject*

SWIG_Python_ErrorType(int code) {

PyObject* type = 0;

switch(code) {

case SWIG_MemoryError:

type = PyExc_MemoryError;

break;

case SWIG_IOError:

type = PyExc_IOError;

break;

case SWIG_RuntimeError:

type = PyExc_RuntimeError;

break;

case SWIG_IndexError:

type = PyExc_IndexError;

break;

case SWIG_TypeError:

type = PyExc_TypeError;

break;

case SWIG_DivisionByZero:

type = PyExc_ZeroDivisionError;

break;

case SWIG_OverflowError:

type = PyExc_OverflowError;

break;

case SWIG_SyntaxError:

type = PyExc_SyntaxError;

break;

case SWIG_ValueError:

type = PyExc_ValueError;

break;

case SWIG_SystemError:

type = PyExc_SystemError;

break;

case SWIG_AttributeError:

type = PyExc_AttributeError;

break;

default:

type = PyExc_RuntimeError;

}

return type;

}