/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.4.0
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


#define SWIG_VERSION 0x040400
#define SWIGPYTHON
#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

#define SWIG_name    "_RNA"
/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NOEXCEPT noexcept
#else
# define SWIG_NOEXCEPT throw()
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if !defined(PY_SSIZE_T_CLEAN) && !defined(SWIG_NO_PY_SSIZE_T_CLEAN)
#define PY_SSIZE_T_CLEAN
#endif

#if __GNUC__ >= 7
#pragma GCC diagnostic push
#if defined(__cplusplus) && __cplusplus >=201703L
#pragma GCC diagnostic ignored "-Wregister" /* For python-2.7 headers that use register */
#endif
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */

#if defined(_MSC_VER) && _MSC_VER >= 1929
/* Workaround compilation errors when redefining _DEBUG in MSVC 2019 version 16.10 and later
 * See https://github.com/swig/swig/issues/2090 */
# include <corecrt.h>
#endif

# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif


#if __GNUC__ >= 7
#pragma GCC diagnostic pop
#endif

#include <stdio.h>
#include <stdlib.h>

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "5"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#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)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4
#define SWIG_POINTER_CLEAR         0x8
#define SWIG_POINTER_RELEASE       (SWIG_POINTER_CLEAR | SWIG_POINTER_DISOWN)

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows returning the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
/* Runtime errors are < 0 */
#define SWIG_ERROR                 (-1)
/* Errors in range -1 to -99 are in swigerrors.swg (errors for all languages including those not using the runtime) */
/* Errors in range -100 to -199 are language specific errors defined in *errors.swg */
/* Errors < -200 are generic runtime specific errors */
#define SWIG_ERROR_RELEASE_NOT_OWNED (-200)

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

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporary objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del object mask methods */
#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))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  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)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next array of casts | pointer to cast hashed by value */
  unsigned int            value;		/* index of the last valid element in the array | typename hash value */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
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));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
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;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
 * Hash function for type name strings, based on maRushPrime1Hash (http://amsoftware.narod.ru/algo2.html)
 */
SWIGRUNTIME unsigned int SWIG_Hash(const char *str, unsigned int len) {
  const unsigned char *data = (const unsigned char *)str;
  unsigned int hash = len, i = 0, k;
  int rem = (int)len;

  while (rem >= (int)sizeof(unsigned int)) {
    k = *(unsigned int *)data;
    k += i++;
    hash ^= k;
    hash *= 171717;
    data += sizeof(unsigned int);
    rem -= sizeof(unsigned int);
  }

  switch (rem) {
    case 3: k = (unsigned int)(data[2]) << 16;
            k |= (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 2: k = (unsigned int)(data[1]) << 8;
            k |= (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
    case 1: k = (unsigned int)(data[0]);
            k += i++;
            hash ^= k;
            hash *= 171717;
            break;
  }
  return hash;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  static const unsigned int scan_threshold = 4;
  if (ty) {
    swig_cast_info *head = ty->cast;
    unsigned int hash_value = 0;
    int hashed = 0;

    while (head) {

      if (strcmp(head->type->name, c) == 0) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;
        int search = 1;

        if (!hashed) {
          if (head->value < scan_threshold) {
            for (iter = first; iter <= last; iter++) {
              if (strcmp(iter->type->name, c) == 0) {
                return iter;
              }
            }
            search = 0;
          } else {
            hashed = 1;
            hash_value = SWIG_Hash(c, (unsigned int)strlen(c));
          }
        }

        if (search) {
          /* Binary search over sorted <'next'|'value'> pairs */
          do {
            iter = first + ((last - first) >> 1);
            if (iter->value < hash_value) {
              first = iter + 1;
            } else if (iter->value == hash_value) {

              if (strcmp(iter->next->type->name, c) == 0) {
                return iter->next;
              }

              /* Hash collision check */
              for (last = iter + 1; last->next && last->value == hash_value; last++) {
                if (strcmp(last->next->type->name, c) == 0) {
                  return last->next;
                }
              }
              for (first = iter - 1; first != head && first->value == hash_value; first--) {
                if (strcmp(first->next->type->name, c) == 0) {
                  return first->next;
                }
              }
              break;
            } else
              last = iter - 1;
          } while (first <= last);
        }
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Check the type by type address
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *head = ty->cast;
    while (head) {
      if (head->type == from) {
        return head;
      }

      if (head->value) {
        swig_cast_info *iter;
        swig_cast_info *last = head + head->value;
        swig_cast_info *first = head + 1;

        /* Binary search over sorted array of casts */
        do {
          iter = first + ((last - first) >> 1);
          if (iter->type < from) {
            first = iter + 1;
          } else if (iter->type == from) {
            return iter;
          } else
            last = iter - 1;
        } while (first <= last);
      }
      head = head->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
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;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  Choose the last
     name. It should be the most specific; a fully resolved name
     but not necessarily with default template parameters expanded. */
  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;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *head = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (head) {
    swig_cast_info *cast;
    for (cast = head; (cast - head) <= head->value; cast++) {
      if (!cast->converter) {
        swig_type_info *tc = cast->type;
        if (!tc->clientdata) {
          SWIG_TypeClientData(tc, clientdata);
        }
      }
    }
    head = head->next;
  }
}

SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
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;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
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
       of the str field (the human readable name) */
    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;
}

/*
   Pack binary data into a string
*/
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;
}

/*
   Unpack binary data from a string
*/
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 = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
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
}
#endif

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#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 >= 0x03030000 && !defined(SWIG_NO_HEAPTYPES)
#if !defined(SWIG_HEAPTYPES)
#define SWIG_HEAPTYPES
#endif
#endif

/* Compatibility macros for Python 3 */
#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 _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif

#if defined(SWIG_HEAPTYPES)
#if PY_VERSION_HEX < 0x030c0000
#include <structmember.h>
#define Py_READONLY READONLY
#define Py_T_PYSSIZET T_PYSSIZET
#endif
#endif

#include <stddef.h> /* For offsetof */


/* Wrapper around PyUnicode_AsUTF8AndSize - call Py_XDECREF on the returned pbytes when finished with the returned string */
SWIGINTERN const char *
SWIG_PyUnicode_AsUTF8AndSize(PyObject *str, Py_ssize_t *psize, PyObject **pbytes)
{
#if PY_VERSION_HEX >= 0x03030000
# if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000
  *pbytes = NULL;
  return PyUnicode_AsUTF8AndSize(str, psize);
# else
  const char *chars;
  *pbytes = PyUnicode_AsUTF8String(str);
  chars = *pbytes ? PyBytes_AsString(*pbytes) : NULL;
  if (chars && psize)
    *psize = PyBytes_Size(*pbytes);
  return chars;
# endif
#else
  char *chars = NULL;
  *pbytes = NULL;
  PyString_AsStringAndSize(str, &chars, psize);
  return chars;
#endif
}

SWIGINTERN PyObject *
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

#define SWIG_RUNTIME_MODULE "swig_runtime_data" SWIG_RUNTIME_VERSION

/* SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user interface files check for it. */
# define SWIGPY_USE_CAPSULE
#ifdef SWIGPYTHON_BUILTIN
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule_builtin" SWIG_TYPE_TABLE_NAME
#else
# define SWIGPY_CAPSULE_ATTR_NAME "type_pointer_capsule" SWIG_TYPE_TABLE_NAME
#endif
#define SWIGPY_CAPSULE_NAME SWIG_RUNTIME_MODULE "." SWIGPY_CAPSULE_ATTR_NAME

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

#if defined(Py_LIMITED_API)
# define PyTuple_GET_ITEM PyTuple_GetItem
/* Note that PyTuple_SetItem() has different semantics from PyTuple_SET_ITEM as it decref's the original tuple item, so in general they cannot be used
  interchangeably. However in SWIG-generated code PyTuple_SET_ITEM is only used with newly initialized tuples without any items and for them this does work. */
# define PyTuple_SET_ITEM PyTuple_SetItem
# define PyTuple_GET_SIZE PyTuple_Size
# define PyCFunction_GET_FLAGS PyCFunction_GetFlags
# define PyCFunction_GET_FUNCTION PyCFunction_GetFunction
# define PyCFunction_GET_SELF PyCFunction_GetSelf
# define PyList_GET_ITEM PyList_GetItem
# define PyList_SET_ITEM PyList_SetItem
# define PySliceObject PyObject
#endif

/* Increment and Decrement wrappers - for portability when using the stable abi and for performance otherwise */
#ifdef Py_LIMITED_API
# define SWIG_Py_INCREF Py_IncRef
# define SWIG_Py_XINCREF Py_IncRef
# define SWIG_Py_DECREF Py_DecRef
# define SWIG_Py_XDECREF Py_DecRef
#else
# define SWIG_Py_INCREF Py_INCREF
# define SWIG_Py_XINCREF Py_XINCREF
# define SWIG_Py_DECREF Py_DECREF
# define SWIG_Py_XDECREF Py_XDECREF
#endif

#if PY_VERSION_HEX >= 0x03000000
#if PY_VERSION_HEX < 0x030d00a6
SWIGINTERN PyObject *
SWIG_PyType_GetFullyQualifiedName(PyTypeObject *type) {
  PyObject *result = NULL;
  PyObject *qualname = PyObject_GetAttrString((PyObject *)type, "__qualname__");
  if (qualname) {
    PyObject *mod = PyObject_GetAttrString((PyObject *)type, "__module__");
    if (mod) {
      if (PyUnicode_Check(mod) && PyUnicode_CompareWithASCIIString(mod, "builtins") && PyUnicode_CompareWithASCIIString(mod, "__main__")) {
        result = PyUnicode_FromFormat("%U%c%U", mod, '.', qualname);
        SWIG_Py_DECREF(qualname);
      } else {
        result = qualname;
      }
      SWIG_Py_DECREF(mod);
    } else {
      result = qualname;
    }
  }

  return result;
}
#else
# define SWIG_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName
#endif
#endif

/* gh-114329 added PyList_GetItemRef() to Python 3.13.0a4 */
#if PY_VERSION_HEX < 0x030d00a4
SWIGINTERN PyObject *
SWIG_PyList_GetItemRef(PyObject *op, Py_ssize_t index) {
  PyObject *item = PyList_GetItem(op, index);
  Py_XINCREF(item);
  return item;
}
#else
# define SWIG_PyList_GetItemRef PyList_GetItemRef
#endif

/* gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef() to Python 3.13.0a1
   functions are renamed here for compatibility with abi3audit */
#if PY_VERSION_HEX < 0x030d00a1
SWIGINTERN int
SWIG_PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result) {
#if PY_VERSION_HEX >= 0x03000000
  PyObject *item = PyDict_GetItemWithError(mp, key);
#else
  PyObject *item = _PyDict_GetItemWithError(mp, key);
#endif
  if (item != NULL) {
    *result = (PyObject *)(item);
    SWIG_Py_INCREF(*result);
    return 1;
  }
  if (!PyErr_Occurred()) {
    *result = NULL;
    return 0;
  }
  *result = NULL;
  return -1;
}

SWIGINTERN int
SWIG_PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result) {
  int res;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *key_obj = PyUnicode_FromString(key);
#else
  PyObject *key_obj = PyString_FromString(key);
#endif
  if (key_obj == NULL) {
    *result = NULL;
    return -1;
  }
  res = SWIG_PyDict_GetItemRef(mp, key_obj, result);
  Py_DECREF(key_obj);
  return res;
}
#else
# define SWIG_PyDict_GetItemRef PyDict_GetItemRef
# define SWIG_PyDict_GetItemStringRef PyDict_GetItemStringRef
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

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;
  case SWIG_NullReferenceError:
    type = PyExc_TypeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
    PyErr_Clear();
    SWIG_Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_DECREF(old_str);
    SWIG_Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    if (newvalue) {
      SWIG_Py_XDECREF(value);
      PyErr_Restore(type, newvalue, traceback);
    } else {
      PyErr_Restore(type, value, traceback);
    }
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      if PY_VERSION_HEX < 0x03070000
#        define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
#      else
#        define SWIG_PYTHON_INITIALIZE_THREADS
#      endif
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { status = false; PyEval_RestoreThread(save); }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03050000
# error "This version of SWIG only supports Python 3 >= 3.5"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   

/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  SWIG_Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  SWIG_Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  SWIG_Py_DECREF(obj);
}

#endif

/* SWIG runtime data Python module */
static PyObject *Swig_runtime_data_module_global = NULL;

/* Create/obtain the single swig_runtime_data module which is used across different SWIG generated modules */
SWIGINTERN PyObject *
SWIG_runtime_data_module(void) {
  if (!Swig_runtime_data_module_global) {
#if PY_VERSION_HEX >= 0x030d0000
    /* free-threading note: the GIL is always enabled when this function is first called
       by SWIG_init, so there's no risk of race conditions */
    Swig_runtime_data_module_global = PyImport_AddModuleRef(SWIG_RUNTIME_MODULE);
#elif PY_VERSION_HEX >= 0x03000000
    Swig_runtime_data_module_global = PyImport_AddModule(SWIG_RUNTIME_MODULE);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#else
    static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
    Swig_runtime_data_module_global = Py_InitModule(SWIG_RUNTIME_MODULE, swig_empty_runtime_method_table);
    SWIG_Py_XINCREF(Swig_runtime_data_module_global);
#endif
  }
  assert(Swig_runtime_data_module_global);
  return Swig_runtime_data_module_global;
}

/* Append a value to the result obj */
SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj, int is_void) {
  if (!result) {
    result = obj;
  } else if (result == Py_None && is_void) {
    SWIG_Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      if (result) {
        PyList_SET_ITEM(result, 0, o2);
      } else {
        SWIG_Py_DECREF(obj);
        return o2;
      }
    }
    PyList_Append(result,obj);
    SWIG_Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

SWIGINTERN int
SWIG_Python_CheckNoKeywords(PyObject *kwargs, const char *name) {
  int no_kwargs = 1;
  if (kwargs) {
    assert(PyDict_Check(kwargs));
    if (PyDict_Size(kwargs) > 0) {
      PyErr_Format(PyExc_TypeError, "%s() does not take keyword arguments", name);
      no_kwargs = 0;
    }
  }
  return no_kwargs;
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

#ifdef __cplusplus
extern "C" {
#endif

/* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
 
/* -----------------------------------------------------------------------------
 * global variable support code.
 * ----------------------------------------------------------------------------- */
 
typedef struct swig_globalvar {   
  char       *name;                  /* Name of global variable */
  PyObject *(*get_attr)(void);       /* Return the current value */
  int       (*set_attr)(PyObject *); /* Set the value */
  struct swig_globalvar *next;
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar *vars;
} swig_varlinkobject;

SWIGINTERN PyObject *
SwigVarLink_repr(PyObject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_InternFromString("<Swig global variables>");
#else
  return PyString_FromString("<Swig global variables>");
#endif
}

SWIGINTERN PyObject *
SwigVarLink_str(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
#if PY_VERSION_HEX >= 0x03000000
  PyObject *str = PyUnicode_InternFromString("(");
  PyObject *tail;
  PyObject *joined;
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    tail = PyUnicode_FromString(var->name);
    joined = PyUnicode_Concat(str, tail);
    SWIG_Py_DECREF(str);
    SWIG_Py_DECREF(tail);
    str = joined;
    if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        SWIG_Py_DECREF(str);
        SWIG_Py_DECREF(tail);
        str = joined;
    }
  }
  tail = PyUnicode_InternFromString(")");
  joined = PyUnicode_Concat(str, tail);
  SWIG_Py_DECREF(str);
  SWIG_Py_DECREF(tail);
  str = joined;
#else
  PyObject *str = PyString_FromString("(");
  swig_globalvar *var;
  for (var = v->vars; var; var=var->next) {
    PyString_ConcatAndDel(&str,PyString_FromString(var->name));
    if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
  }
  PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
  return str;
}

SWIGINTERN void
SwigVarLink_dealloc(PyObject *o) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  swig_globalvar *var = v->vars;
  while (var) {
    swig_globalvar *n = var->next;
    free(var->name);
    free(var);
    var = n;
  }
}

SWIGINTERN PyObject *
SwigVarLink_getattr(PyObject *o, char *n) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  PyObject *res = NULL;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->get_attr)();
      break;
    }
    var = var->next;
  }
  if (res == NULL && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN int
SwigVarLink_setattr(PyObject *o, char *n, PyObject *p) {
  swig_varlinkobject *v = (swig_varlinkobject *) o;
  int res = 1;
  swig_globalvar *var = v->vars;
  while (var) {
    if (strcmp(var->name,n) == 0) {
      res = (*var->set_attr)(p);
      break;
    }
    var = var->next;
  }
  if (res == 1 && !PyErr_Occurred()) {
    PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
  }
  return res;
}

SWIGINTERN PyTypeObject*
SwigVarLink_TypeOnce(void) {
  static char SwigVarLink_doc[] = "Swig variable link object";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject varlink_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                  /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigVarLink", /* tp_name */
      sizeof(swig_varlinkobject),         /* tp_basicsize */
      0,                                  /* tp_itemsize */
      (destructor) SwigVarLink_dealloc,   /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                       /* tp_print */
#else
      (Py_ssize_t)0,                      /* tp_vectorcall_offset */
#endif
      (getattrfunc) SwigVarLink_getattr,  /* tp_getattr */
      (setattrfunc) SwigVarLink_setattr,  /* tp_setattr */
      0,                                  /* tp_compare */
      (reprfunc) SwigVarLink_repr,        /* tp_repr */
      0,                                  /* tp_as_number */
      0,                                  /* tp_as_sequence */
      0,                                  /* tp_as_mapping */
      0,                                  /* tp_hash */
      0,                                  /* tp_call */
      (reprfunc) SwigVarLink_str,         /* tp_str */
      0,                                  /* tp_getattro */
      0,                                  /* tp_setattro */
      0,                                  /* tp_as_buffer */
      0,                                  /* tp_flags */
      SwigVarLink_doc,                    /* tp_doc */
      0,                                  /* tp_traverse */
      0,                                  /* tp_clear */
      0,                                  /* tp_richcompare */
      0,                                  /* tp_weaklistoffset */
      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
      0,                                  /* tp_del */
      0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                  /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                  /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                  /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                  /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                  /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                  /* tp_allocs */
      0,                                  /* tp_frees */
      0,                                  /* tp_maxalloc */
      0,                                  /* tp_prev */
      0                                   /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    varlink_type = tmp;
    type_init = 1;
    if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigVarLink", (PyObject *)&varlink_type) == 0)
      SWIG_Py_INCREF((PyObject *)&varlink_type);
  }
  return &varlink_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigVarLink_dealloc },
    { Py_tp_repr, (void *)SwigVarLink_repr },
    { Py_tp_getattr, (void *)SwigVarLink_getattr },
    { Py_tp_setattr, (void *)SwigVarLink_setattr },
    { Py_tp_str, (void *)SwigVarLink_str },
    { Py_tp_doc, (void *)SwigVarLink_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigVarLink",
    sizeof(swig_varlinkobject),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigVarLink", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyTypeObject*
SwigVarLink_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigVarLink_TypeOnce();
  return type;
}

/* Create a variable linking object for use later */
SWIGINTERN PyObject *
SWIG_Python_newvarlink(void) {
  swig_varlinkobject *result = PyObject_New(swig_varlinkobject, SwigVarLink_Type());
  if (result) {
    result->vars = 0;
  }
  return ((PyObject*) result);
}

SWIGINTERN void 
SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
  swig_varlinkobject *v = (swig_varlinkobject *) p;
  swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  if (gv) {
    size_t size = strlen(name)+1;
    gv->name = (char *)malloc(size);
    if (gv->name) {
      memcpy(gv->name, name, size);
      gv->get_attr = get_attr;
      gv->set_attr = set_attr;
      gv->next = v->vars;
    }
  }
  v->vars = gv;
}


static PyObject *Swig_Globals_global = NULL;
  
SWIGINTERN PyObject *
SWIG_globals(void) {
  if (Swig_Globals_global == NULL) {
    Swig_Globals_global = SWIG_newvarlink();
  }
  return Swig_Globals_global;
}

#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  SWIG_Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    SWIG_Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      SWIG_Py_INCREF(obj);
      data->newargs = obj;
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
        data->newargs = PyTuple_New(1);
        if (data->newargs) {
          SWIG_Py_INCREF(obj);
          PyTuple_SET_ITEM(data->newargs, 0, obj);
        } else {
          SWIG_Py_DECREF(data->newraw);
          SWIG_Py_DECREF(data->klass);
          free(data);
          return 0;
        }
      } else {
        SWIG_Py_INCREF(obj);
        data->newargs = obj;
      }
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O);
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data)
{
  SWIG_Py_XDECREF(data->klass);
  SWIG_Py_XDECREF(data->newraw);
  SWIG_Py_XDECREF(data->newargs);
  SWIG_Py_XDECREF(data->destroy);
  free(data);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
  PyObject *swigdict;
  PyObject *weakreflist;
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->swigdict)
    sobj->swigdict = PyDict_New();

  SWIG_Py_XINCREF(sobj->swigdict);
  return sobj->swigdict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    PyObject *val = SwigPyObject_long(v);
    if (val) {
      PyObject *ofmt;
      PyTuple_SET_ITEM(args, 0, val);
      ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
        res = PyUnicode_Format(ofmt,args);
#else
        res = PyString_Format(ofmt,args);
#endif
        SWIG_Py_DECREF(ofmt);
      }
    }
    SWIG_Py_DECREF(args);
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (repr && v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
    if (nrep) {
# if PY_VERSION_HEX >= 0x03000000
      PyObject *joined = PyUnicode_Concat(repr, nrep);
      SWIG_Py_DECREF(repr);
      SWIG_Py_DECREF(nrep);
      repr = joined;
# else
      PyString_ConcatAndDel(&repr,nrep);
# endif
    } else {
      SWIG_Py_DECREF(repr);
      repr = NULL;
    }
  }
  return repr;
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in SwigPyObject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(PyObject *v, PyObject *w)
{
  /* tp_compare is only called when both objects have the same type, so
   * the casts are guaranteed to be ok. */
  void *i = ((SwigPyObject *)v)->ptr;
  void *j = ((SwigPyObject *)w)->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

SWIGRUNTIMEINLINE int SwigPyObject_Check(PyObject *);

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(PyObject *v, PyObject *w, int op)
{
  PyObject* res = NULL;
  if (!PyErr_Occurred()) {
    /* Per https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_richcompare
     * the first argument is guaranteed to be an instance of SwigPyObject, but the
     * second is not, so we typecheck that one. */
    if ((op != Py_EQ && op != Py_NE) || !SwigPyObject_Check(w)) {
      SWIG_Py_INCREF(Py_NotImplemented);
      return Py_NotImplemented;
    }
    res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  }
  return res;
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyObject_Type();
  PyTypeObject *op_type = Py_TYPE(op);
#ifdef SWIGPYTHON_BUILTIN
  /* Only builtin types have SwigPyObject as a base type */
  return PyType_IsSubtype(op_type, target_tp);
#else
  /* Check for an exact match to SwigPyObject */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyObject");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyObject") == 0;
#endif
  }
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

static PyObject* Swig_Capsule_global = NULL;

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        if (tmp) {
          res = SWIG_Python_CallFunctor(destroy, tmp);
        } else {
          res = 0;
        }
        SWIG_Py_XDECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      SWIG_Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
    SWIG_Py_XDECREF(Swig_Capsule_global);
  }
  SWIG_Py_XDECREF(next);
  SWIG_Py_XDECREF(sobj->swigdict);
  PyObject_Free(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  ((SwigPyObject *)next)->next = sobj->next;
  sobj->next = next;
  SWIG_Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    SWIG_Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SWIG_Py_DECREF(SwigPyObject_acquire(v,args));
      } else {
        SWIG_Py_DECREF(SwigPyObject_disown(v,args));
      }
    } 
    return obj;
  }
}

static PyMethodDef
SwigPyObject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char SwigPyObject_doc[] = "Swig object holding a C/C++ pointer";
#ifndef SWIG_HEAPTYPES
  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyObject",  /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyObject_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      offsetof(SwigPyObject, weakreflist),  /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      SwigPyObject_methods,                 /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyObject", (PyObject *)&swigpyobject_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpyobject_type);
  }
  return &swigpyobject_type;
#else
  static PyMemberDef SwigPyObject_members[] = {
      { (char *)"__dictoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, swigdict), Py_READONLY, NULL },
      { (char *)"__weaklistoffset__", Py_T_PYSSIZET, offsetof(SwigPyObject, weakreflist), Py_READONLY, NULL },
      { NULL, 0, 0, 0, NULL }
  };
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyObject_dealloc },
    { Py_tp_repr, (void *)SwigPyObject_repr },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyObject_doc },
    { Py_tp_richcompare, (void *)SwigPyObject_richcompare },
    { Py_tp_methods, (void *)SwigPyObject_methods },
    { Py_nb_int, (void *)SwigPyObject_long },
    { Py_tp_members, (void *)SwigPyObject_members },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyObject",
    sizeof(SwigPyObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
#if !defined(Py_LIMITED_API)
/* While this __dictoffset__ is only used with the builtin wrappers, SwigPyObject ought to be
   identical when created for use by proxy class wrappers in case it is shared across multiple modules. */
#if PY_VERSION_HEX < 0x03090000
    /* Workaround as __dictoffset__ and __weaklistoffset__ above are only supported from python-3.9 */
  if (pytype) {
    ((PyTypeObject *)pytype)->tp_dictoffset = offsetof(SwigPyObject, swigdict);
    ((PyTypeObject *)pytype)->tp_weaklistoffset = offsetof(SwigPyObject, weakreflist);
  }
#endif
#endif
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyObject", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_New(SwigPyObject, SwigPyObject_Type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
    sobj->swigdict = 0;
    sobj->weakreflist = 0;
    if (own == SWIG_POINTER_OWN) {
      /* Obtain a reference to the Python capsule wrapping the module information, so that the
       * module information is correctly destroyed after all SWIG python objects have been freed
       * by the GC (and corresponding destructors invoked) */
      SWIG_Py_XINCREF(Swig_Capsule_global);
    }
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_Type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  PyTypeObject *target_tp = SwigPyPacked_Type();
  PyTypeObject *op_type = Py_TYPE(op);
  /* Check for an exact match to SwigPyPacked */
  if (op_type == target_tp) {
    return 1;
  } else {
    /* Fallback for multiple modules */
#if PY_VERSION_HEX >= 0x03000000
    int cmp;
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(op_type);
    if (!tpname)
      return 0;
    cmp = PyUnicode_CompareWithASCIIString(tpname, SWIG_RUNTIME_MODULE ".SwigPyPacked");
    SWIG_Py_DECREF(tpname);
    return cmp == 0;
#else
    return strcmp(op_type->tp_name, SWIG_RUNTIME_MODULE ".SwigPyPacked") == 0;
#endif
  }
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_Free(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char SwigPyPacked_doc[] = "Swig object holding a C/C++ function pointer";
#ifndef SWIG_HEAPTYPES
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      SWIG_RUNTIME_MODULE ".SwigPyPacked",  /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
#if PY_VERSION_HEX < 0x030800b4
      (printfunc)0,                         /* tp_print */
#else
      (Py_ssize_t)0,                        /* tp_vectorcall_offset */
#endif
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      SwigPyPacked_doc,                     /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#if PY_VERSION_HEX >= 0x03080000
      0,                                    /* tp_vectorcall */
#endif
#if (PY_VERSION_HEX >= 0x03080000) && (PY_VERSION_HEX < 0x03090000)
      0,                                    /* tp_print */
#endif
#if PY_VERSION_HEX >= 0x030c0000
      0,                                    /* tp_watched */
#endif
#if PY_VERSION_HEX >= 0x030d00a4
      0,                                    /* tp_versions_used */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    PyObject *runtime_data_module = SWIG_runtime_data_module();
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) != 0)
      return NULL;
    if (PyModule_AddObject(runtime_data_module, "SwigPyPacked", (PyObject *)&swigpypacked_type) == 0)
      SWIG_Py_INCREF((PyObject *)&swigpypacked_type);
  }
  return &swigpypacked_type;
#else
  PyType_Slot slots[] = {
    { Py_tp_dealloc, (void *)SwigPyPacked_dealloc },
    { Py_tp_repr, (void *)SwigPyPacked_repr },
    { Py_tp_str, (void *)SwigPyPacked_str },
    { Py_tp_getattro, (void *)PyObject_GenericGetAttr },
    { Py_tp_doc, (void *)SwigPyPacked_doc },
    { 0, NULL }
  };
  PyType_Spec spec = {
    SWIG_RUNTIME_MODULE ".SwigPyPacked",
    sizeof(SwigPyPacked),
    0,
    Py_TPFLAGS_DEFAULT,
    slots
  };
  PyObject *pytype = PyType_FromSpec(&spec);
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  if (pytype && PyModule_AddObject(runtime_data_module, "SwigPyPacked", pytype) == 0)
    SWIG_Py_INCREF(pytype);
  return (PyTypeObject *)pytype;
#endif
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_New(SwigPyPacked, SwigPyPacked_Type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_Free((PyObject *)sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX >= 0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

/* Returns a borrowed reference to the 'this' object */
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
  if (PyWeakref_CheckProxy(pyobj)) {
#if PY_VERSION_HEX >= 0x030d0000
    if (PyWeakref_GetRef(pyobj, &pyobj) > 0)
      Py_DECREF(pyobj);
    else
      pyobj = NULL;
#else
    pyobj = PyWeakref_GetObject(pyobj);
#endif
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
      if (PyWeakref_CheckProxy(pyobj)) {
        PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
      obj = PyObject_GetAttr(pyobj, SWIG_This());
      if (obj) {
	SWIG_Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj, SWIG_This());
  if (obj) {
    SWIG_Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !sobj->own) {
      res = SWIG_ERROR_RELEASE_NOT_OWNED;
    } else {
      if (own)
        *own = *own | sobj->own;
      if (flags & SWIG_POINTER_DISOWN) {
        sobj->own = 0;
      }
      if (flags & SWIG_POINTER_CLEAR) {
        sobj->ptr = 0;
      }
      res = SWIG_OK;
    }
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            SWIG_Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
#ifndef Py_LIMITED_API
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
#else
    PyObject* pystr_doc = PyObject_GetAttrString(obj, "__doc__");
    PyObject *bytes = NULL;
    const char *doc = pystr_doc ? SWIG_PyUnicode_AsUTF8AndSize(pystr_doc, NULL, &bytes) : 0;
#endif
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
#ifdef Py_LIMITED_API
    SWIG_Py_XDECREF(bytes);
    SWIG_Py_XDECREF(pystr_doc);
#endif
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
        PyObject *dict = *dictptr;
        if (dict == NULL) {
          dict = PyDict_New();
          *dictptr = dict;
        }
        if (dict) {
          PyDict_SetItem(dict, SWIG_This(), swig_this);
        } else{
          SWIG_Py_DECREF(inst);
          inst = 0;
        }
      }
#else
      if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
        SWIG_Py_DECREF(inst);
        inst = 0;
      }
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
#ifndef Py_LIMITED_API
        newfunc newfn = ((PyTypeObject *)data->newargs)->tp_new;
#else
        newfunc newfn = (newfunc)PyType_GetSlot((PyTypeObject *)data->newargs, Py_tp_new);
#endif
        inst = newfn((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        SWIG_Py_DECREF(empty_kwargs);
        if (inst) {
          if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) {
            SWIG_Py_DECREF(inst);
            inst = 0;
          } else {
            PyType_Modified(Py_TYPE(inst));
          }
        }
      }
      SWIG_Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      SWIG_Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME int
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  PyObject **dictptr = _PyObject_GetDictPtr(inst);
  if (dictptr != NULL) {
    PyObject *dict = *dictptr;
    if (dict == NULL) {
      dict = PyDict_New();
      *dictptr = dict;
    }
    if (dict) {
      return PyDict_SetItem(dict, SWIG_This(), swig_this);
    } else{
      return -1;
    }
  }
#endif
  return PyObject_SetAttr(inst, SWIG_This(), swig_this);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SWIG_Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1]));
    } else {
      if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0)
        return NULL;
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
#ifndef Py_LIMITED_API
        allocfunc alloc = clientdata->pytype->tp_alloc;
#else
        allocfunc alloc = (allocfunc)PyType_GetSlot(clientdata->pytype, Py_tp_alloc);
#endif
        PyObject *next_self = alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
      if (newobj) {
        newobj->swigdict = 0;
        newobj->weakreflist = 0;
      }
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    SWIG_Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

static PyObject *Swig_TypeCache_global = NULL;

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  if (Swig_TypeCache_global == NULL) {
    Swig_TypeCache_global = PyDict_New();
  }
  return Swig_TypeCache_global;
}

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
#ifdef SWIG_LINK_RUNTIME
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
  }
#else
  void *type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
  if (PyErr_Occurred()) {
    PyErr_Clear();
    type_pointer = (void *)0;
  }
#endif
  return (swig_module_info *) type_pointer;
}


#if defined(SWIG_REFCNT_DEBUG)
#define SWIG_PYOBJ_REFCNT(OBJ) fprintf(stdout, "" #OBJ " count %ld\n", (OBJ ? Py_REFCNT(OBJ) : 0))
#else
#define SWIG_PYOBJ_REFCNT(OBJ)
#endif

static int interpreter_counter = 0; /* how many (sub-)interpreters are using swig_module's types */

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  if (--interpreter_counter != 0) /* another sub-interpreter may still be using the swig_module's types */
    return;
  for (i = 0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      ty->clientdata = 0;
      if (data) SwigPyClientData_Del(data);
    }
  }
  SWIG_PYOBJ_REFCNT(Swig_This_global);
  SWIG_Py_XDECREF(Swig_This_global);
  Swig_This_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Globals_global);
  SWIG_Py_XDECREF(Swig_Globals_global);
  Swig_Globals_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_TypeCache_global);
  SWIG_Py_XDECREF(Swig_TypeCache_global);
  Swig_TypeCache_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_Capsule_global);
  Swig_Capsule_global = NULL;

  SWIG_PYOBJ_REFCNT(Swig_runtime_data_module_global);
  SWIG_Py_XDECREF(Swig_runtime_data_module_global);
  Swig_runtime_data_module_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
  PyObject *runtime_data_module = SWIG_runtime_data_module();
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && runtime_data_module) {
    if (PyModule_AddObject(runtime_data_module, SWIGPY_CAPSULE_ATTR_NAME, pointer) == 0) {
      ++interpreter_counter;
      Swig_Capsule_global = pointer;
    } else {
      SWIG_Py_DECREF(pointer);
    }
  } else {
    SWIG_Py_XDECREF(pointer);
  }
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  swig_type_info *descriptor;
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *obj;
  SWIG_PyDict_GetItemStringRef(cache, type, &obj);
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      if (obj) PyDict_SetItemString(cache, type, obj);
    }
  }
  SWIG_Py_XDECREF(obj);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      PyObject *bytes = NULL;
      const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(old_str, NULL, &bytes);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      SWIG_Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Py_XDECREF(bytes);
      SWIG_Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = Py_TYPE(obj);
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(Py_TYPE(name));
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%S'", tpname);
    SWIG_Py_DECREF(tpname);
#else
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%s'", Py_TYPE(name)->tp_name);
#endif
    return -1;
  } else {
    SWIG_Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) != 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = Py_TYPE(descr)->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      SWIG_Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        goto done;
    }
#if PY_VERSION_HEX >= 0x03000000
    {
      PyObject *tpname = SWIG_PyType_GetFullyQualifiedName(tp);
      PyErr_Format(PyExc_AttributeError, "'%S' object has no attribute '%s'", tpname, PyString_AsString(encoded_name));
      SWIG_Py_DECREF(tpname);
    }
#else
    PyErr_Format(PyExc_AttributeError, "'%s' object has no attribute '%s'", tp->tp_name, PyString_AsString(encoded_name));
#endif
    SWIG_Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  SWIG_Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) do { if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } } while (0) 



  #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0) 


/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_COORDINATE swig_types[0]
#define SWIGTYPE_p_FILE swig_types[1]
#define SWIGTYPE_p_SOLUTION swig_types[2]
#define SWIGTYPE_p_Tree swig_types[3]
#define SWIGTYPE_p__struct_en swig_types[4]
#define SWIGTYPE_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double swig_types[5]
#define SWIGTYPE_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray swig_types[6]
#define SWIGTYPE_p_a_5__a_5__double swig_types[7]
#define SWIGTYPE_p_a_5__a_5__doubleArray swig_types[8]
#define SWIGTYPE_p_a_5__a_5__int swig_types[9]
#define SWIGTYPE_p_a_5__a_5__intArray swig_types[10]
#define SWIGTYPE_p_a_5__double swig_types[11]
#define SWIGTYPE_p_a_5__doubleArray swig_types[12]
#define SWIGTYPE_p_a_7_1__a_5__a_5__a_5__a_5__int swig_types[13]
#define SWIGTYPE_p_a_7_1__a_5__a_5__a_5__a_5__intArray swig_types[14]
#define SWIGTYPE_p_a_7_1__a_5__a_5__a_5__int swig_types[15]
#define SWIGTYPE_p_a_7_1__a_5__a_5__a_5__intArray swig_types[16]
#define SWIGTYPE_p_a_7_1__a_5__a_5__int swig_types[17]
#define SWIGTYPE_p_a_7_1__a_5__a_5__intArray swig_types[18]
#define SWIGTYPE_p_a_MAXLOOP_1__double swig_types[19]
#define SWIGTYPE_p_a_MAXLOOP_1__doubleArray swig_types[20]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double swig_types[21]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray swig_types[22]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int swig_types[23]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray swig_types[24]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__double swig_types[25]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray swig_types[26]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__int swig_types[27]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__intArray swig_types[28]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__double swig_types[29]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__doubleArray swig_types[30]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__int swig_types[31]
#define SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__intArray swig_types[32]
#define SWIGTYPE_p_a_NBPAIRS_1__double swig_types[33]
#define SWIGTYPE_p_a_NBPAIRS_1__doubleArray swig_types[34]
#define SWIGTYPE_p_allocator_type swig_types[35]
#define SWIGTYPE_p_char swig_types[36]
#define SWIGTYPE_p_difference_type swig_types[37]
#define SWIGTYPE_p_double swig_types[38]
#define SWIGTYPE_p_doubleArray swig_types[39]
#define SWIGTYPE_p_duplexT swig_types[40]
#define SWIGTYPE_p_duplex_list_t swig_types[41]
#define SWIGTYPE_p_first_type swig_types[42]
#define SWIGTYPE_p_float swig_types[43]
#define SWIGTYPE_p_floatArray swig_types[44]
#define SWIGTYPE_p_heat_capacity_result swig_types[45]
#define SWIGTYPE_p_int swig_types[46]
#define SWIGTYPE_p_intArray swig_types[47]
#define SWIGTYPE_p_my_fc_type_e swig_types[48]
#define SWIGTYPE_p_p_PyObject swig_types[49]
#define SWIGTYPE_p_p_char swig_types[50]
#define SWIGTYPE_p_p_int swig_types[51]
#define SWIGTYPE_p_p_intArray swig_types[52]
#define SWIGTYPE_p_p_p_char swig_types[53]
#define SWIGTYPE_p_p_short swig_types[54]
#define SWIGTYPE_p_p_unsigned_int swig_types[55]
#define SWIGTYPE_p_p_var_arrayT_vrna_move_t_t swig_types[56]
#define SWIGTYPE_p_p_void swig_types[57]
#define SWIGTYPE_p_second_type swig_types[58]
#define SWIGTYPE_p_short swig_types[59]
#define SWIGTYPE_p_size_type swig_types[60]
#define SWIGTYPE_p_std__allocatorT_COORDINATE_t swig_types[61]
#define SWIGTYPE_p_std__allocatorT_SOLUTION_t swig_types[62]
#define SWIGTYPE_p_std__allocatorT_char_const_p_t swig_types[63]
#define SWIGTYPE_p_std__allocatorT_double_t swig_types[64]
#define SWIGTYPE_p_std__allocatorT_duplex_list_t_t swig_types[65]
#define SWIGTYPE_p_std__allocatorT_heat_capacity_result_t swig_types[66]
#define SWIGTYPE_p_std__allocatorT_int_t swig_types[67]
#define SWIGTYPE_p_std__allocatorT_std__string_t swig_types[68]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_double_t_t swig_types[69]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_int_t_t swig_types[70]
#define SWIGTYPE_p_std__allocatorT_std__vectorT_unsigned_int_t_t swig_types[71]
#define SWIGTYPE_p_std__allocatorT_subopt_solution_t swig_types[72]
#define SWIGTYPE_p_std__allocatorT_unsigned_int_t swig_types[73]
#define SWIGTYPE_p_std__allocatorT_vrna_ep_t_t swig_types[74]
#define SWIGTYPE_p_std__allocatorT_vrna_hx_t_t swig_types[75]
#define SWIGTYPE_p_std__allocatorT_vrna_move_t_t swig_types[76]
#define SWIGTYPE_p_std__allocatorT_vrna_path_t_t swig_types[77]
#define SWIGTYPE_p_std__pairT_double_double_t swig_types[78]
#define SWIGTYPE_p_std__string swig_types[79]
#define SWIGTYPE_p_std__vectorT_COORDINATE_t swig_types[80]
#define SWIGTYPE_p_std__vectorT_SOLUTION_t swig_types[81]
#define SWIGTYPE_p_std__vectorT_char_const_p_t swig_types[82]
#define SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t swig_types[83]
#define SWIGTYPE_p_std__vectorT_double_t swig_types[84]
#define SWIGTYPE_p_std__vectorT_duplex_list_t_t swig_types[85]
#define SWIGTYPE_p_std__vectorT_heat_capacity_result_t swig_types[86]
#define SWIGTYPE_p_std__vectorT_int_t swig_types[87]
#define SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t swig_types[88]
#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[89]
#define SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t swig_types[90]
#define SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t swig_types[91]
#define SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t swig_types[92]
#define SWIGTYPE_p_std__vectorT_subopt_solution_t swig_types[93]
#define SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t swig_types[94]
#define SWIGTYPE_p_std__vectorT_unsigned_int_t swig_types[95]
#define SWIGTYPE_p_std__vectorT_vrna_ep_t_t swig_types[96]
#define SWIGTYPE_p_std__vectorT_vrna_hx_t_t swig_types[97]
#define SWIGTYPE_p_std__vectorT_vrna_move_t_t swig_types[98]
#define SWIGTYPE_p_std__vectorT_vrna_path_t_t swig_types[99]
#define SWIGTYPE_p_subopt_solution swig_types[100]
#define SWIGTYPE_p_swString swig_types[101]
#define SWIGTYPE_p_swig__SwigPyIterator swig_types[102]
#define SWIGTYPE_p_unsigned_int swig_types[103]
#define SWIGTYPE_p_unsigned_short swig_types[104]
#define SWIGTYPE_p_value_type swig_types[105]
#define SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t swig_types[106]
#define SWIGTYPE_p_var_arrayT_char_t swig_types[107]
#define SWIGTYPE_p_var_arrayT_int_t swig_types[108]
#define SWIGTYPE_p_var_arrayT_short_t swig_types[109]
#define SWIGTYPE_p_var_arrayT_unsigned_char_t swig_types[110]
#define SWIGTYPE_p_var_arrayT_unsigned_int_t swig_types[111]
#define SWIGTYPE_p_var_arrayT_vrna_move_t_t swig_types[112]
#define SWIGTYPE_p_void swig_types[113]
#define SWIGTYPE_p_vrna_basepair_s swig_types[114]
#define SWIGTYPE_p_vrna_basepair_t swig_types[115]
#define SWIGTYPE_p_vrna_bp_stack_t swig_types[116]
#define SWIGTYPE_p_vrna_command_s swig_types[117]
#define SWIGTYPE_p_vrna_cpair_s swig_types[118]
#define SWIGTYPE_p_vrna_dimer_pf_s swig_types[119]
#define SWIGTYPE_p_vrna_dotplot_auxdata_t swig_types[120]
#define SWIGTYPE_p_vrna_elem_prob_s swig_types[121]
#define SWIGTYPE_p_vrna_ep_t swig_types[122]
#define SWIGTYPE_p_vrna_exp_param_t swig_types[123]
#define SWIGTYPE_p_vrna_fold_compound_t swig_types[124]
#define SWIGTYPE_p_vrna_hc_t swig_types[125]
#define SWIGTYPE_p_vrna_hx_t swig_types[126]
#define SWIGTYPE_p_vrna_md_t swig_types[127]
#define SWIGTYPE_p_vrna_move_t swig_types[128]
#define SWIGTYPE_p_vrna_mx_mfe_t swig_types[129]
#define SWIGTYPE_p_vrna_mx_pf_t swig_types[130]
#define SWIGTYPE_p_vrna_param_t swig_types[131]
#define SWIGTYPE_p_vrna_path_options_s swig_types[132]
#define SWIGTYPE_p_vrna_path_s swig_types[133]
#define SWIGTYPE_p_vrna_path_t swig_types[134]
#define SWIGTYPE_p_vrna_pbacktrack_mem_t swig_types[135]
#define SWIGTYPE_p_vrna_pinfo_s swig_types[136]
#define SWIGTYPE_p_vrna_plot_data_t swig_types[137]
#define SWIGTYPE_p_vrna_plot_layout_t swig_types[138]
#define SWIGTYPE_p_vrna_plot_options_puzzler_t swig_types[139]
#define SWIGTYPE_p_vrna_probing_data_s swig_types[140]
#define SWIGTYPE_p_vrna_sc_mod_param_s swig_types[141]
#define SWIGTYPE_p_vrna_sc_s swig_types[142]
#define SWIGTYPE_p_vrna_score_t swig_types[143]
#define SWIGTYPE_p_vrna_smx_csr_FLT_OR_DBL_s swig_types[144]
static swig_type_info *swig_types[146];
static swig_module_info swig_module = {swig_types, 145, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= _RNA.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__RNA

#else
#  define SWIG_init    init_RNA

#endif

#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif


#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 


#include <stdexcept>


namespace swig {
  class SwigPtr_PyObject {
  protected:
    PyObject *_obj;

  public:
    SwigPtr_PyObject() :_obj(0)
    {
    }

    SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
    {
      if (initial_ref) {
        SWIG_PYTHON_THREAD_BEGIN_BLOCK;
        SWIG_Py_XINCREF(_obj);
        SWIG_PYTHON_THREAD_END_BLOCK;
      }
    }
    
    SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item) 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XINCREF(item._obj);
      SWIG_Py_XDECREF(_obj);
      _obj = item._obj;
      SWIG_PYTHON_THREAD_END_BLOCK;
      return *this;      
    }
    
    ~SwigPtr_PyObject() 
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      SWIG_Py_XDECREF(_obj);
      SWIG_PYTHON_THREAD_END_BLOCK;
    }
    
    operator PyObject *() const
    {
      return _obj;
    }

    PyObject *operator->() const
    {
      return _obj;
    }
  };
}


namespace swig {
  struct SwigVar_PyObject : SwigPtr_PyObject {
    SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
    
    SwigVar_PyObject & operator = (PyObject* obj)
    {
      SWIG_Py_XDECREF(_obj);
      _obj = obj;
      return *this;      
    }
  };
}



extern "C" {
#include  <ViennaRNA/model.h>
#include  <ViennaRNA/datastructures/basic.h>
#include  <ViennaRNA/datastructures/array.h>
#include  <ViennaRNA/datastructures/sparse_mx.h>
#include  <ViennaRNA/datastructures/dp_matrices.h>
#include  <ViennaRNA/fold_compound.h>
#include  <ViennaRNA/unstructured_domains.h>
#include  <ViennaRNA/structured_domains.h>

#include  <ViennaRNA/grammar/basic.h>
#include  <ViennaRNA/grammar/mfe.h>
#include  <ViennaRNA/grammar/partfunc.h>

#include  <ViennaRNA/utils/basic.h>
#include  <ViennaRNA/utils/strings.h>
#include  <ViennaRNA/utils/log.h>
#include  <ViennaRNA/fold_vars.h>

#include <ViennaRNA/sequences/alphabet.h>
#include <ViennaRNA/sequences/sequence.h>
#include <ViennaRNA/sequences/alignments.h>
#include <ViennaRNA/sequences/utils.h>

#include <ViennaRNA/structures/benchmark.h>
#include <ViennaRNA/structures/dotbracket.h>
#include <ViennaRNA/structures/helix.h>
#include <ViennaRNA/structures/metrics.h>
#include <ViennaRNA/structures/pairtable.h>
#include <ViennaRNA/structures/problist.h>
#include <ViennaRNA/structures/shapes.h>
#include <ViennaRNA/structures/tree.h>
#include <ViennaRNA/structures/utils.h>
#include <ViennaRNA/structures/centroid.h>
#include <ViennaRNA/structures/mea.h>

#include  <ViennaRNA/params/constants.h>
#include  <ViennaRNA/params/basic.h>
#include  <ViennaRNA/params/io.h>
#include  <ViennaRNA/params/salt.h>
#include  <ViennaRNA/params/default.h>

#include  <ViennaRNA/constraints/basic.h>
#include  <ViennaRNA/constraints/hard.h>
#include  <ViennaRNA/constraints/soft.h>
#include  <ViennaRNA/constraints/soft_special.h>
#include  <ViennaRNA/constraints/ligand.h>

#include  <ViennaRNA/probing/basic.h>
#include  <ViennaRNA/probing/SHAPE.h>
#include  <ViennaRNA/probing/strategy_deigan.h>
#include  <ViennaRNA/probing/strategy_eddy.h>
#include  <ViennaRNA/probing/strategy_zarringhalam.h>

#include  <ViennaRNA/data/transform.h>

#include  <ViennaRNA/math/functions.h>

#ifdef VRNA_WITH_NAVIEW_LAYOUT
#include  <ViennaRNA/plotting/naview/naview.h>
#endif
#include  <ViennaRNA/plotting/layouts.h>
#include  <ViennaRNA/plotting/structures.h>
#include  <ViennaRNA/plotting/alignments.h>
#include  <ViennaRNA/plotting/probabilities.h>

#include  <ViennaRNA/io/commands.h>
#include  <ViennaRNA/io/file_formats.h>
#include  <ViennaRNA/io/file_formats_msa.h>
#include  <ViennaRNA/io/utils.h>

#include  <ViennaRNA/eval/basic.h>
#include  <ViennaRNA/eval/structures.h>
#include  <ViennaRNA/eval/exterior.h>
#include  <ViennaRNA/eval/hairpin.h>
#include  <ViennaRNA/eval/internal.h>
#include  <ViennaRNA/eval/multibranch.h>
#include  <ViennaRNA/eval/gquad.h>

#include  <ViennaRNA/mfe/global.h>
#include  <ViennaRNA/mfe/local.h>
#include  <ViennaRNA/mfe/exterior.h>
#include  <ViennaRNA/mfe/internal.h>
#include  <ViennaRNA/mfe/multibranch.h>
#include  <ViennaRNA/mfe/gquad.h>

#include  <ViennaRNA/backtrack/global.h>
#include  <ViennaRNA/backtrack/exterior.h>
#include  <ViennaRNA/backtrack/internal.h>
#include  <ViennaRNA/backtrack/multibranch.h>
#include  <ViennaRNA/backtrack/gquad.h>

#include  <ViennaRNA/partfunc/global.h>
#include  <ViennaRNA/partfunc/local.h>
#include  <ViennaRNA/partfunc/exterior.h>
#include  <ViennaRNA/partfunc/internal.h>
#include  <ViennaRNA/partfunc/multibranch.h>
#include  <ViennaRNA/partfunc/gquad.h>

#include  <ViennaRNA/subopt/basic.h>
#include  <ViennaRNA/subopt/wuchty.h>
#include  <ViennaRNA/subopt/zuker.h>

#include  <ViennaRNA/sampling/basic.h>

#include  <ViennaRNA/probabilities/basepairs.h>
#include  <ViennaRNA/probabilities/structures.h>

#include  <ViennaRNA/fold.h>
#include  <ViennaRNA/cofold.h>
#include  <ViennaRNA/alifold.h>

#include  <ViennaRNA/part_func_co.h>
#include  <ViennaRNA/concentrations.h>
#include  <ViennaRNA/wrap_dlib.h>
#include  <ViennaRNA/LPfold.h>
#include  <ViennaRNA/heat_capacity.h>

#ifdef VRNA_WITH_SVM
#include  <ViennaRNA/zscore/basic.h>
#endif

#include  <ViennaRNA/inverse/basic.h>

#include  <ViennaRNA/RNAstruct.h>
#include  <ViennaRNA/treedist.h>
#include  <ViennaRNA/stringdist.h>
#include  <ViennaRNA/profiledist.h>
#include  <ViennaRNA/dist_vars.h>
#include  <ViennaRNA/pair_mat.h>
#include  <ViennaRNA/duplex.h>

#include  <ViennaRNA/combinatorics/basic.h>

#include  <ViennaRNA/move_set.h>
#include  <ViennaRNA/landscape/paths.h>
#include  <ViennaRNA/landscape/findpath.h>
#include  <ViennaRNA/landscape/move.h>
#include  <ViennaRNA/landscape/neighbor.h>
#include  <ViennaRNA/landscape/walk.h>

#include  <ViennaRNA/mm.h>

#include  <ViennaRNA/static/energy_parameter_sets.h>
#include  <ViennaRNA/static/probing_data_priors.h>
}



  static int *new_intP(size_t nelements) { 
    return (new int[nelements]());
  }

  static void delete_intP(int *ary) {
    delete[] ary;
  }

  static int intP_getitem(int *ary, size_t index) {
    return ary[index];
  }
  static void intP_setitem(int *ary, size_t index, int value) {
    ary[index] = value;
  }


SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


#include <errno.h>


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx, cx, rd;
   errno = 0;
   fx = floor(x);
   cx = ceil(x);
   rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val) 
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    long v = PyInt_AsLong(obj);
    if (v >= 0) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      return SWIG_OverflowError;
    }
  } else
#endif
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than ULONG_MAX (not portably calculated easily)
      // Note that double(ULONG_MAX) is stored in a double rounded up by one (for 64-bit unsigned long)
      // 0xfffffffffffff800ULL == (uint64_t)std::nextafter(double(__uint128_t(ULONG_MAX)+1), double(0))
      const double ulong_max = sizeof(unsigned long) == 8 ? 0xfffffffffffff800ULL : ULONG_MAX;
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ulong_max)) {
	if (val) *val = (unsigned long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


#if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
#  define SWIG_LONG_LONG_AVAILABLE
#endif


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    unsigned long long v = PyLong_AsUnsignedLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
      if (val) *val = (unsigned long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_size_t (PyObject * obj, size_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    unsigned long v;
    res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
    unsigned long long v;
    res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  }
#endif
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      // Largest double not larger than LONG_MAX (not portably calculated easily)
      // Note that double(LONG_MAX) is stored in a double rounded up by one (for 64-bit long)
      // 0x7ffffffffffffc00LL == (int64_t)std::nextafter(double(__uint128_t(LONG_MAX)+1), double(0))
      const double long_max = sizeof(long) == 8 ? 0x7ffffffffffffc00LL : LONG_MAX;
      // No equivalent needed for 64-bit double(LONG_MIN) is exactly LONG_MIN
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, long_max)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< int >(v);
    }
  }  
  return res;
}


typedef int intArray;

SWIGINTERN intArray *new_intArray(size_t nelements){
    return (new int[nelements]());
  }
SWIGINTERN void delete_intArray(intArray *self){
    delete[] self;
  }
SWIGINTERN int intArray___getitem__(intArray *self,size_t index){
    return self[index];
  }
SWIGINTERN void intArray___setitem__(intArray *self,size_t index,int value){
    self[index] = value;
  }
SWIGINTERN int *intArray_cast(intArray *self){
    return self;
  }
SWIGINTERN intArray *intArray_frompointer(int *t){
    return static_cast< intArray * >(t);
  }

  static float *new_floatP(size_t nelements) { 
    return (new float[nelements]());
  }

  static void delete_floatP(float *ary) {
    delete[] ary;
  }

  static float floatP_getitem(float *ary, size_t index) {
    return ary[index];
  }
  static void floatP_setitem(float *ary, size_t index, float value) {
    ary[index] = value;
  }


  #define SWIG_From_double   PyFloat_FromDouble 


SWIGINTERNINLINE PyObject *
SWIG_From_float  (float value)
{    
  return SWIG_From_double  (value);
}


/* Getting isfinite working pre C99 across multiple platforms is non-trivial. Users can provide SWIG_isfinite on older platforms. */
#ifndef SWIG_isfinite
/* isfinite() is a macro for C99 */
# if defined(isfinite)
#  define SWIG_isfinite(X) (isfinite(X))
# elif defined(__cplusplus) && __cplusplus >= 201103L
/* Use a template so that this works whether isfinite() is std::isfinite() or
 * in the global namespace.  The reality seems to vary between compiler
 * versions.
 *
 * Make sure namespace std exists to avoid compiler warnings.
 *
 * extern "C++" is required as this fragment can end up inside an extern "C" { } block
 */
namespace std { }
extern "C++" template<typename T>
inline int SWIG_isfinite_func(T x) {
  using namespace std;
  return isfinite(x);
}
#  define SWIG_isfinite(X) (SWIG_isfinite_func(X))
# elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
#  define SWIG_isfinite(X) (__builtin_isfinite(X))
# elif defined(_MSC_VER)
#  define SWIG_isfinite(X) (_finite(X))
# elif defined(__sun) && defined(__SVR4)
#  include <ieeefp.h>
#  define SWIG_isfinite(X) (finite(X))
# endif
#endif


/* Accept infinite as a valid float value unless we are unable to check if a value is finite */
#ifdef SWIG_isfinite
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX) && SWIG_isfinite(X))
#else
# define SWIG_Float_Overflow_Check(X) ((X < -FLT_MAX || X > FLT_MAX))
#endif


SWIGINTERN int
SWIG_AsVal_float (PyObject * obj, float *val)
{
  double v;
  int res = SWIG_AsVal_double (obj, &v);
  if (SWIG_IsOK(res)) {
    if (SWIG_Float_Overflow_Check(v)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< float >(v);
    }
  }  
  return res;
}


typedef float floatArray;

SWIGINTERN floatArray *new_floatArray(size_t nelements){
    return (new float[nelements]());
  }
SWIGINTERN void delete_floatArray(floatArray *self){
    delete[] self;
  }
SWIGINTERN float floatArray___getitem__(floatArray *self,size_t index){
    return self[index];
  }
SWIGINTERN void floatArray___setitem__(floatArray *self,size_t index,float value){
    self[index] = value;
  }
SWIGINTERN float *floatArray_cast(floatArray *self){
    return self;
  }
SWIGINTERN floatArray *floatArray_frompointer(float *t){
    return static_cast< floatArray * >(t);
  }

  static double *new_doubleP(size_t nelements) { 
    return (new double[nelements]());
  }

  static void delete_doubleP(double *ary) {
    delete[] ary;
  }

  static double doubleP_getitem(double *ary, size_t index) {
    return ary[index];
  }
  static void doubleP_setitem(double *ary, size_t index, double value) {
    ary[index] = value;
  }


typedef double doubleArray;

SWIGINTERN doubleArray *new_doubleArray(size_t nelements){
    return (new double[nelements]());
  }
SWIGINTERN void delete_doubleArray(doubleArray *self){
    delete[] self;
  }
SWIGINTERN double doubleArray___getitem__(doubleArray *self,size_t index){
    return self[index];
  }
SWIGINTERN void doubleArray___setitem__(doubleArray *self,size_t index,double value){
    self[index] = value;
  }
SWIGINTERN double *doubleArray_cast(doubleArray *self){
    return self;
  }
SWIGINTERN doubleArray *doubleArray_frompointer(double *t){
    return static_cast< doubleArray * >(t);
  }

  static unsigned short *new_ushortP(size_t nelements) { 
    return (new unsigned short[nelements]());
  }

  static void delete_ushortP(unsigned short *ary) {
    delete[] ary;
  }

  static unsigned short ushortP_getitem(unsigned short *ary, size_t index) {
    return ary[index];
  }
  static void ushortP_setitem(unsigned short *ary, size_t index, unsigned short value) {
    ary[index] = value;
  }


  #define SWIG_From_long   PyInt_FromLong 


SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long  (unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
}


SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


SWIGINTERN int
SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > USHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned short >(v);
    }
  }  
  return res;
}


  static short *new_shortP(size_t nelements) { 
    return (new short[nelements]());
  }

  static void delete_shortP(short *ary) {
    delete[] ary;
  }

  static short shortP_getitem(short *ary, size_t index) {
    return ary[index];
  }
  static void shortP_setitem(short *ary, size_t index, short value) {
    ary[index] = value;
  }


SWIGINTERNINLINE PyObject *
SWIG_From_short  (short value)
{    
  return SWIG_From_long  (value);
}


SWIGINTERN int
SWIG_AsVal_short (PyObject * obj, short *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < SHRT_MIN || v > SHRT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< short >(v);
    }
  }  
  return res;
}


typedef struct SWIGCDATA {
  char *data;
  size_t len;
} SWIGCDATA;



extern "C"  {


static SWIGCDATA cdata_void(void *ptr, size_t nelements)



{
  SWIGCDATA d;
  d.data = (char *) ptr;



  d.len  = nelements;

   return d;
}

}



SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static swig_type_info* info = 0;
  if (!info) {
    info = SWIG_TypeQuery("_p_char");
  }
  return info;
}


SWIGINTERNINLINE PyObject *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  if (carray) {
    if (size > (size_t)PY_SSIZE_T_MAX) {
      swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
      return pchar_descriptor ? 
	SWIG_InternalNewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
    } else {
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
      return PyBytes_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#else
      return PyUnicode_DecodeUTF8(carray, static_cast< Py_ssize_t >(size), "surrogateescape");
#endif
#else
      return PyString_FromStringAndSize(carray, static_cast< Py_ssize_t >(size));
#endif
    }
  } else {
    return SWIG_Py_Void();
  }
}


/* Return string from Python obj. NOTE: obj must remain in scope in order
   to use the returned cptr (but only when alloc is set to SWIG_OLDOBJ) */
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char **cptr, size_t *psize, int *alloc)
{
#if PY_VERSION_HEX >= 0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    PyObject *bytes = NULL;
    int ret = SWIG_OK;
    if (alloc)
      *alloc = SWIG_OLDOBJ;
#if PY_VERSION_HEX >= 0x03000000 && defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (PyBytes_AsStringAndSize(obj, &cstr, &len) == -1)
      return SWIG_TypeError;
#else
    cstr = (char *)SWIG_PyUnicode_AsUTF8AndSize(obj, &len, &bytes);
    if (!cstr)
      return SWIG_TypeError;
    /* The returned string is only duplicated if the char * returned is not owned and memory managed by obj */
    if (bytes && cptr) {
      if (alloc) {
        cstr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        *alloc = SWIG_NEWOBJ;
      } else {
        /* alloc must be set in order to clean up allocated memory */
        return SWIG_RuntimeError;
      }
    }
#endif
    if (cptr) *cptr = cstr;
    if (psize) *psize = len + 1;
    SWIG_Py_XDECREF(bytes);
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX < 0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = reinterpret_cast< char* >(memcpy(new char[len + 1], cstr, sizeof(char)*(len + 1)));
        }
        if (psize) *psize = len + 1;

        SWIG_Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        SWIG_Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


/** @file version.i.in
 * @brief Set RNA.__version__ to the bindings version
 */


#include <typeinfo>
#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <string>


#include <stddef.h>


#include <utility>


#include <iostream>

#if PY_VERSION_HEX >= 0x03020000
# define SWIGPY_SLICEOBJECT PyObject
#else
# define SWIGPY_SLICEOBJECT PySliceObject
#endif


namespace swig {
  struct SwigPyIterator {
  private:
    SwigPtr_PyObject _seq;

  protected:
    SwigPyIterator(PyObject *seq) : _seq(seq)
    {
    }

    void raise_stop_iteration() const
    {
      SWIG_SetErrorObj(PyExc_StopIteration, SWIG_Py_Void());
    }

  public:
    virtual ~SwigPyIterator() {}

    // Access iterator method, required by Python
    virtual PyObject *value() const = 0;

    // Forward iterator method, required by Python
    virtual SwigPyIterator *incr(size_t n = 1) = 0;
    
    // Backward iterator method, very common in C++, but not required in Python
    // This default probably ought to instead raise some sort of unsupported exception
    virtual SwigPyIterator *decr(size_t /*n*/ = 1)
    {
      raise_stop_iteration();
      return NULL;
    }

    // Random access iterator methods, but not required in Python
    virtual ptrdiff_t distance(const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }

    virtual bool equal (const SwigPyIterator &/*x*/) const
    {
      throw std::invalid_argument("operation not supported");
    }
    
    // C++ common/needed methods
    virtual SwigPyIterator *copy() const = 0;

    PyObject *next()     
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      PyObject *obj = value();
      if (obj)
        if (!incr())
          obj = NULL;
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads
      return obj;     
    }

    /* Make an alias for Python 3.x */
    PyObject *__next__()
    {
      return next();
    }

    PyObject *previous()
    {
      SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads       
      if (!decr())
        return NULL;
      PyObject *obj = value();
      SWIG_PYTHON_THREAD_END_BLOCK; // re-enable threads       
      return obj;
    }

    SwigPyIterator *advance(ptrdiff_t n)
    {
      return  (n > 0) ?  incr(n) : decr(-n);
    }
      
    bool operator == (const SwigPyIterator& x)  const
    {
      return equal(x);
    }
      
    bool operator != (const SwigPyIterator& x) const
    {
      return ! operator==(x);
    }
      
    SwigPyIterator& operator += (ptrdiff_t n)
    {
      SwigPyIterator *ret = advance(n);
      return ret ? *ret : *this;
    }

    SwigPyIterator& operator -= (ptrdiff_t n)
    {
      SwigPyIterator *ret = advance(-n);
      return ret ? *ret : *this;
    }
      
    SwigPyIterator* operator + (ptrdiff_t n) const
    {
      return copy()->advance(n);
    }

    SwigPyIterator* operator - (ptrdiff_t n) const
    {
      return copy()->advance(-n);
    }
      
    ptrdiff_t operator - (const SwigPyIterator& x) const
    {
      return x.distance(*this);
    }
      
    static swig_type_info* descriptor() {
      static swig_type_info* desc = SWIG_TypeQuery("swig::SwigPyIterator *");
      return desc;
    }    
  };

#if defined(SWIGPYTHON_BUILTIN)
  inline PyObject* make_output_iterator_builtin (PyObject *pyself)
  {
    SWIG_Py_INCREF(pyself);
    return pyself;
  }
#endif
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_long_SS_long  (long long value)
{
  return ((value < LONG_MIN) || (value > LONG_MAX)) ?
    PyLong_FromLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    return SWIG_From_long  (static_cast< long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(ptrdiff_t) <= sizeof(long long) */
    return SWIG_From_long_SS_long  (static_cast< long long >(value));
  }
#endif
}


SWIGINTERNINLINE PyObject*
  SWIG_From_bool  (bool value)
{
  return PyBool_FromLong(value ? 1 : 0);
}


#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERN int
SWIG_AsVal_long_SS_long (PyObject *obj, long long *val)
{
  int res = SWIG_TypeError;
  if (PyLong_Check(obj)) {
    long long v = PyLong_AsLongLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      res = SWIG_OverflowError;
    }
  } else {
    long v;
    res = SWIG_AsVal_long (obj,&v);
    if (SWIG_IsOK(res)) {
      if (val) *val = v;
      return res;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    const double mant_max = 1LL << DBL_MANT_DIG;
    const double mant_min = -mant_max;
    double d;
    res = SWIG_AsVal_double (obj,&d);
    if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, mant_min, mant_max))
      return SWIG_OverflowError;
    if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, mant_min, mant_max)) {
      if (val) *val = (long long)(d);
      return SWIG_AddCast(res);
    }
    res = SWIG_TypeError;
  }
#endif
  return res;
}
#endif


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (PyObject * obj, ptrdiff_t *val)
{
  int res = SWIG_TypeError;
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(ptrdiff_t) <= sizeof(long)) {
#endif
    long v;
    res = SWIG_AsVal_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else if (sizeof(ptrdiff_t) <= sizeof(long long)) {
    long long v;
    res = SWIG_AsVal_long_SS_long (obj, val ? &v : 0);
    if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  }
#endif
  return res;
}


#include <algorithm>


#include <vector>


namespace swig {
  template <class Type>
  struct noconst_traits {
    typedef Type noconst_type;
  };

  template <class Type>
  struct noconst_traits<const Type> {
    typedef Type noconst_type;
  };

  /*
    type categories
  */
  struct pointer_category { };
  struct value_category { };

  /*
    General traits that provides type_name and type_info
  */
  template <class Type> struct traits { };

  template <class Type>
  inline const char* type_name() {
    return traits<typename noconst_traits<Type >::noconst_type >::type_name();
  }

  template <class Type> struct traits_info {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  /*
    Partial specialization for pointers (traits_info)
  */
  template <class Type> struct traits_info<Type *> {
    static swig_type_info *type_query(std::string name) {
      name += " *";
      return SWIG_TypeQuery(name.c_str());
    }
    static swig_type_info *type_info() {
      static swig_type_info *info = type_query(type_name<Type>());
      return info;
    }
  };

  template <class Type>
  inline swig_type_info *type_info() {
    return traits_info<Type>::type_info();
  }

  /*
    Partial specialization for pointers (traits)
  */
  template <class Type> struct traits <Type *> {
    typedef pointer_category category;
    static std::string make_ptr_name(const char* name) {
      std::string ptrname = name;
      ptrname += " *";
      return ptrname;
    }
    static const char* type_name() {
      static std::string name = make_ptr_name(swig::type_name<Type>());
      return name.c_str();
    }
  };

  template <class Type, class Category>
  struct traits_as { };

  template <class Type, class Category>
  struct traits_check { };

}


namespace swig {  
  /*
    Traits that provides the from method
  */
  template <class Type> struct traits_from_ptr {
    static PyObject *from(Type *val, int owner = 0) {
      return SWIG_InternalNewPointerObj(val, type_info<Type>(), owner);
    }
  };

  template <class Type> struct traits_from {
    static PyObject *from(const Type& val) {
      return traits_from_ptr<Type>::from(new Type(val), 1);
    }
  };

  template <class Type> struct traits_from<Type *> {
    static PyObject *from(Type* val) {
      return traits_from_ptr<Type>::from(val, 0);
    }
  };

  template <class Type> struct traits_from<const Type *> {
    static PyObject *from(const Type* val) {
      return traits_from_ptr<Type>::from(const_cast<Type*>(val), 0);
    }
  };


  template <class Type>
  inline PyObject *from(const Type& val) {
    return traits_from<Type>::from(val);
  }

  template <class Type>
  inline PyObject *from_ptr(Type* val, int owner) {
    return traits_from_ptr<Type>::from(val, owner);
  }

  /*
    Traits that provides the asval/as/check method
  */
  template <class Type>
  struct traits_asptr {   
    static int asptr(PyObject *obj, Type **val) {
      int res = SWIG_ERROR;
      swig_type_info *descriptor = type_info<Type>();
      if (val) {
        Type *p = 0;
        int newmem = 0;
        res = descriptor ? SWIG_ConvertPtrAndOwn(obj, (void **)&p, descriptor, 0, &newmem) : SWIG_ERROR;
        if (SWIG_IsOK(res)) {
          if (newmem & SWIG_CAST_NEW_MEMORY) {
            res |= SWIG_NEWOBJMASK;
          }
          *val = p;
        }
      } else {
        res = descriptor ? SWIG_ConvertPtr(obj, 0, descriptor, 0) : SWIG_ERROR;
      }
      return res;
    }
  }; 

  template <class Type>
  inline int asptr(PyObject *obj, Type **vptr) {
    return traits_asptr<Type>::asptr(obj, vptr);
  }

  template <class Type> 
  struct traits_asval {
    static int asval(PyObject *obj, Type *val) {
      if (val) {
	Type *p = 0;
	int res = traits_asptr<Type>::asptr(obj, &p);
	if (!SWIG_IsOK(res)) return res;	
	if (p) {
	  typedef typename noconst_traits<Type>::noconst_type noconst_type;
	  *(const_cast<noconst_type*>(val)) = *p;
	  if (SWIG_IsNewObj(res)){
	    delete p;
	    res = SWIG_DelNewMask(res);
	  }
	  return res;
	} else {
	  return SWIG_ERROR;
	}
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };

  template <class Type> struct traits_asval<Type*> {
    static int asval(PyObject *obj, Type **val) {
      if (val) {
        typedef typename noconst_traits<Type>::noconst_type noconst_type;
        noconst_type *p = 0;
        int res = traits_asptr<noconst_type>::asptr(obj,  &p);
        if (SWIG_IsOK(res)) {
          *(const_cast<noconst_type**>(val)) = p;
	}
	return res;
      } else {
	return traits_asptr<Type>::asptr(obj, (Type **)(0));
      }
    }
  };
  
  template <class Type>
  inline int asval(PyObject *obj, Type *val) {
    return traits_asval<Type>::asval(obj, val);
  }

  template <class Type> 
  struct traits_as<Type, value_category> {
    static Type as(PyObject *obj) {
      Type v;
      int res = asval(obj, &v);
      if (!obj || !SWIG_IsOK(res)) {
	if (!PyErr_Occurred()) {
	  ::SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
      return v;
    }
  };

  template <class Type> 
  struct traits_as<Type, pointer_category> {
    static Type as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res) && v) {
	if (SWIG_IsNewObj(res)) {
	  Type r(*v);
	  delete v;
	  return r;
	} else {
	  return *v;
	}
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };

  template <class Type> 
  struct traits_as<Type*, pointer_category> {
    static Type* as(PyObject *obj) {
      Type *v = 0;      
      int res = (obj ? traits_asptr<Type>::asptr(obj, &v) : SWIG_ERROR);
      if (SWIG_IsOK(res)) {
	return v;
      } else {
	if (!PyErr_Occurred()) {
	  SWIG_Error(SWIG_TypeError,  swig::type_name<Type>());
	}
	throw std::invalid_argument("bad type");
      }
    }
  };
    
  template <class Type>
  inline Type as(PyObject *obj) {
    return traits_as<Type, typename traits<Type>::category>::as(obj);
  }

  template <class Type> 
  struct traits_check<Type, value_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asval(obj, (Type *)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type> 
  struct traits_check<Type, pointer_category> {
    static bool check(PyObject *obj) {
      int res = obj ? asptr(obj, (Type **)(0)) : SWIG_ERROR;
      return SWIG_IsOK(res) ? true : false;
    }
  };

  template <class Type>
  inline bool check(PyObject *obj) {
    return traits_check<Type, typename traits<Type>::category>::check(obj);
  }
}


namespace swig {
  template <> struct traits< double > {
    typedef value_category category;
    static const char* type_name() { return"double"; }
  };
  template <>  struct traits_asval< double > {
    typedef double value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_double (obj, val);
    }
  };
  template <>  struct traits_from< double > {
    typedef double value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_double  (val);
    }
  };
}


  namespace swig {


















































    template <class T, class U >
    struct traits_asptr<std::pair<T,U> >  {
      typedef std::pair<T,U> value_type;

      static int get_pair(PyObject* first, PyObject* second,
			  std::pair<T,U> **val) 
      {
	if (val) {
	  value_type *vp = (new std::pair<T,U>());
	  T *pfirst = &(vp->first);
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) {
	    delete vp;
	    return res1;
	  }
	  U *psecond = &(vp->second);
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) {
	    delete vp;
	    return res2;
	  }
	  *val = vp;
	  return SWIG_AddNewMask(res1 > res2 ? res1 : res2);
	} else {
	  T *pfirst = 0;
	  int res1 = swig::asval((PyObject*)first, pfirst);
	  if (!SWIG_IsOK(res1)) return res1;
	  U *psecond = 0;
	  int res2 = swig::asval((PyObject*)second, psecond);
	  if (!SWIG_IsOK(res2)) return res2;
	  return res1 > res2 ? res1 : res2;
	}
      }

      static int asptr(PyObject *obj, std::pair<T,U> **val) {
	int res = SWIG_ERROR;
	if (PyTuple_Check(obj)) {
	  if (PyTuple_GET_SIZE(obj) == 2) {
	    res = get_pair(PyTuple_GET_ITEM(obj,0),PyTuple_GET_ITEM(obj,1), val);
	  }
	} else if (PySequence_Check(obj)) {
	  if (PySequence_Size(obj) == 2) {
	    swig::SwigVar_PyObject first = PySequence_GetItem(obj,0);
	    swig::SwigVar_PyObject second = PySequence_GetItem(obj,1);
	    res = get_pair(first, second, val);
	  }
	} else {
	  value_type *p = 0;
	  swig_type_info *descriptor = swig::type_info<value_type>();
	  res = descriptor ? SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0) : SWIG_ERROR;
	  if (SWIG_IsOK(res) && val)  *val = p;
	}
	return res;
      }
    };


    template <class T, class U >
    struct traits_from<std::pair<T,U> >   {
      static PyObject *from(const std::pair<T,U>& val) {
	PyObject* obj = PyTuple_New(2);
	PyTuple_SetItem(obj,0,swig::from(val.first));
	PyTuple_SetItem(obj,1,swig::from(val.second));
	return obj;
      }
    };
  }





































      namespace swig {
	template <>  struct traits<std::pair< double, double > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::pair<" "double" "," "double" " >";
	  }
	};
      }
    

#if defined(__SUNPRO_CC) && defined(_RWSTD_VER)
#  if !defined(SWIG_NO_STD_NOITERATOR_TRAITS_STL)
#    define SWIG_STD_NOITERATOR_TRAITS_STL
#  endif
#endif

#if !defined(SWIG_STD_NOITERATOR_TRAITS_STL)
#include <iterator>
#else
namespace std {
  template <class Iterator>
  struct iterator_traits {
    typedef ptrdiff_t difference_type;
    typedef typename Iterator::value_type value_type;
  };

  template <class Iterator, class Category,class T, class Reference, class Pointer, class Distance>
  struct iterator_traits<__reverse_bi_iterator<Iterator,Category,T,Reference,Pointer,Distance> > {
    typedef Distance difference_type;
    typedef T value_type;
  };

  template <class T>
  struct iterator_traits<T*> {
    typedef T value_type;
    typedef ptrdiff_t difference_type;
  };

  template<typename _InputIterator>
  inline typename iterator_traits<_InputIterator>::difference_type
  distance(_InputIterator __first, _InputIterator __last)
  {
    typename iterator_traits<_InputIterator>::difference_type __n = 0;
    while (__first != __last) {
      ++__first; ++__n;
    }
    return __n;
  }
}
#endif


namespace swig {
  template<typename OutIterator>
  class SwigPyIterator_T :  public SwigPyIterator
  {
  public:
    typedef OutIterator out_iterator;
    typedef typename std::iterator_traits<out_iterator>::value_type value_type;    
    typedef SwigPyIterator_T<out_iterator> self_type;

    SwigPyIterator_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator(seq), current(curr)
    {
    }

    const out_iterator& get_current() const
    {
      return current;
    }

    
    bool equal (const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return (current == iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }
    
    ptrdiff_t distance(const SwigPyIterator &iter) const
    {
      const self_type *iters = dynamic_cast<const self_type *>(&iter);
      if (iters) {
	return std::distance(current, iters->get_current());
      } else {
	throw std::invalid_argument("bad iterator type");
      }
    }    
    
  protected:
    out_iterator current;
  };
  
  template <class ValueType>
  struct from_oper 
  {
    typedef const ValueType& argument_type;
    typedef PyObject *result_type;
    result_type operator()(argument_type v) const
    {
      return swig::from(v);
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyForwardIteratorOpen_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorOpen_T(out_iterator curr, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq)
    {
    }
    
    PyObject *value() const {
      return from(static_cast<const value_type&>(*(base::current)));
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      // Open iterator does not raise StopIteration
      while (n--) {
	++base::current;
      }
      return this;
    }

  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorOpen_T :  public SwigPyForwardIteratorOpen_T<OutIterator, ValueType, FromOper>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyIteratorOpen_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorOpen_T(out_iterator curr, PyObject *seq)
      : SwigPyForwardIteratorOpen_T<OutIterator>(curr, seq)
    {
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      // Open iterator does not raise StopIteration
      while (n--) {
	--base::current;
      }
      return this;
    }
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyForwardIteratorClosed_T :  public SwigPyIterator_T<OutIterator>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;    
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyForwardIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyIterator_T<OutIterator>(curr, seq), begin(first), end(last)
    {
    }
    
    PyObject *value() const {
      if (base::current == end) {
	base::raise_stop_iteration();
	return NULL;
      } else {
	return from(static_cast<const value_type&>(*(base::current)));
      }
    }
    
    SwigPyIterator *copy() const
    {
      return new self_type(*this);
    }

    SwigPyIterator *incr(size_t n = 1)
    {
      while (n--) {
	if (base::current == end) {
	  base::raise_stop_iteration();
	  return NULL;
	} else {
	  ++base::current;
	}
      }
      return this;
    }

  protected:
    out_iterator begin;
    out_iterator end;
  };

  template<typename OutIterator, 
	   typename ValueType = typename std::iterator_traits<OutIterator>::value_type,
	   typename FromOper = from_oper<ValueType> >
  class SwigPyIteratorClosed_T :  public SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>
  {
  public:
    FromOper from;
    typedef OutIterator out_iterator;
    typedef ValueType value_type;
    typedef SwigPyIterator_T<out_iterator>  base;
    typedef SwigPyForwardIteratorClosed_T<OutIterator, ValueType, FromOper> base0;
    typedef SwigPyIteratorClosed_T<OutIterator, ValueType, FromOper> self_type;
    
    SwigPyIteratorClosed_T(out_iterator curr, out_iterator first, out_iterator last, PyObject *seq)
      : SwigPyForwardIteratorClosed_T<OutIterator,ValueType,FromOper>(curr, first, last, seq)
    {
    }

    SwigPyIterator *decr(size_t n = 1)
    {
      while (n--) {
	if (base::current == base0::begin) {
	  base0::raise_stop_iteration();
	  return NULL;
	} else {
	  --base::current;
	}
      }
      return this;
    }
  };


  template<typename OutIter>
  inline SwigPyIterator*
  make_output_forward_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
  {
    return new SwigPyForwardIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, const OutIter& begin,const OutIter& end, PyObject *seq = 0)
  {
    return new SwigPyIteratorClosed_T<OutIter>(current, begin, end, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_forward_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyForwardIteratorOpen_T<OutIter>(current, seq);
  }

  template<typename OutIter>
  inline SwigPyIterator*
  make_output_iterator(const OutIter& current, PyObject *seq = 0)
  {
    return new SwigPyIteratorOpen_T<OutIter>(current, seq);
  }

}


namespace swig {
  template <> struct traits< int > {
    typedef value_category category;
    static const char* type_name() { return"int"; }
  };
  template <>  struct traits_asval< int > {
    typedef int value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_int (obj, val);
    }
  };
  template <>  struct traits_from< int > {
    typedef int value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_int  (val);
    }
  };
}


#include <functional>

namespace std {
  template <>
  struct less <PyObject *>
  {
    bool
    operator()(PyObject * v, PyObject *w) const
    { 
      bool res;
      SWIG_PYTHON_THREAD_BEGIN_BLOCK;
      res = PyObject_RichCompareBool(v, w, Py_LT) ? true : false;
      /* This may fall into a case of inconsistent
               eg. ObjA > ObjX > ObjB
               but ObjA < ObjB
      */
      if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
      {
        /* Objects can't be compared, this mostly occurred in Python 3.0 */
        /* Compare their ptr directly for a workaround */
        res = (v < w);
        PyErr_Clear();
      }
      SWIG_PYTHON_THREAD_END_BLOCK;
      return res;
    }
  };

  template <>
  struct less <swig::SwigPtr_PyObject>
  {
    bool
    operator()(const swig::SwigPtr_PyObject& v, const swig::SwigPtr_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

  template <>
  struct less <swig::SwigVar_PyObject>
  {
    bool
    operator()(const swig::SwigVar_PyObject& v, const swig::SwigVar_PyObject& w) const
    {
      return std::less<PyObject *>()(v, w);
    }
  };

}

namespace swig {
  template <> struct traits<PyObject *> {
    typedef value_category category;
    static const char* type_name() { return "PyObject *"; }
  };  

  template <>  struct traits_asval<PyObject * > {   
    typedef PyObject * value_type;
    static int asval(PyObject *obj, value_type *val) {
      if (val) *val = obj;
      return SWIG_OK;
    }
  };

  template <> 
  struct traits_check<PyObject *, value_category> {
    static bool check(PyObject *) {
      return true;
    }
  };

  template <>  struct traits_from<PyObject *> {
    typedef PyObject * value_type;
    static PyObject *from(const value_type& val) {
      SWIG_Py_XINCREF(val);
      return val;
    }
  };
  
}

namespace swig {
  template <class Difference>
  inline size_t
  check_index(Difference i, size_t size, bool insert = false) {
    if ( i < 0 ) {
      if ((size_t) (-i) <= size)
	return (size_t) (i + size);
    } else if ( (size_t) i < size ) {
      return (size_t) i;
    } else if (insert && ((size_t) i == size)) {
      return size;
    }
    throw std::out_of_range("index out of range");
  }

  template <class Difference>
  void
  slice_adjust(Difference i, Difference j, Py_ssize_t step, size_t size, Difference &ii, Difference &jj, bool insert = false) {
    if (step == 0) {
      throw std::invalid_argument("slice step cannot be zero");
    } else if (step > 0) {
      // Required range: 0 <= i < size, 0 <= j < size, i <= j
      if (i < 0) {
        ii = 0;
      } else if (i < (Difference)size) {
        ii = i;
      } else if (insert && (i >= (Difference)size)) {
        ii = (Difference)size;
      }
      if (j < 0) {
        jj = 0;
      } else {
        jj = (j < (Difference)size) ? j : (Difference)size;
      }
      if (jj < ii)
        jj = ii;
    } else {
      // Required range: -1 <= i < size-1, -1 <= j < size-1, i >= j
      if (i < -1) {
        ii = -1;
      } else if (i < (Difference) size) {
        ii = i;
      } else if (i >= (Difference)(size-1)) {
        ii = (Difference)(size-1);
      }
      if (j < -1) {
        jj = -1;
      } else {
        jj = (j < (Difference)size ) ? j : (Difference)(size-1);
      }
      if (ii < jj)
        ii = jj;
    }
  }

  template <class Sequence, class Difference>
  inline typename Sequence::iterator
  getpos(Sequence* self, Difference i)  {
    typename Sequence::iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence, class Difference>
  inline typename Sequence::const_iterator
  cgetpos(const Sequence* self, Difference i)  {
    typename Sequence::const_iterator pos = self->begin();
    std::advance(pos, check_index(i,self->size()));
    return pos;
  }

  template <class Sequence>
  inline void
  erase(Sequence* seq, const typename Sequence::iterator& position) {
    seq->erase(position);
  }

  template <class Sequence>
  struct traits_reserve {
    static void reserve(Sequence & /*seq*/, typename Sequence::size_type /*n*/) {
      // This should be specialized for types that support reserve
    }
  };

  template <class Sequence, class Difference>
  inline Sequence*
  getslice(const Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj);

    if (step > 0) {
      typename Sequence::const_iterator sb = self->begin();
      typename Sequence::const_iterator se = self->begin();
      std::advance(sb,ii);
      std::advance(se,jj);
      if (step == 1) {
        return new Sequence(sb, se);
      } else {
        Sequence *sequence = new Sequence();
        swig::traits_reserve<Sequence>::reserve(*sequence, (jj - ii + step - 1) / step);
        typename Sequence::const_iterator it = sb;
        while (it!=se) {
          sequence->push_back(*it);
          for (Py_ssize_t c=0; c<step && it!=se; ++c)
            it++;
        }
        return sequence;
      } 
    } else {
      Sequence *sequence = new Sequence();
      swig::traits_reserve<Sequence>::reserve(*sequence, (ii - jj - step - 1) / -step);
      typename Sequence::const_reverse_iterator sb = self->rbegin();
      typename Sequence::const_reverse_iterator se = self->rbegin();
      std::advance(sb,size-ii-1);
      std::advance(se,size-jj-1);
      typename Sequence::const_reverse_iterator it = sb;
      while (it!=se) {
        sequence->push_back(*it);
        for (Py_ssize_t c=0; c<-step && it!=se; ++c)
          it++;
      }
      return sequence;
    }
  }

  template <class Sequence, class Difference, class InputSeq>
  inline void
  setslice(Sequence* self, Difference i, Difference j, Py_ssize_t step, const InputSeq& is = InputSeq()) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      if (step == 1) {
        size_t ssize = jj - ii;
        if (ssize <= is.size()) {
          // expanding/staying the same size
          swig::traits_reserve<Sequence>::reserve(*self, self->size() - ssize + is.size());
          typename Sequence::iterator sb = self->begin();
          typename InputSeq::const_iterator isit = is.begin();
          std::advance(sb,ii);
          std::advance(isit, jj - ii);
          self->insert(std::copy(is.begin(), isit, sb), isit, is.end());
        } else {
          // shrinking
          typename Sequence::iterator sb = self->begin();
          typename Sequence::iterator se = self->begin();
          std::advance(sb,ii);
          std::advance(se,jj);
          self->erase(sb,se);
          sb = self->begin();
          std::advance(sb,ii);
          self->insert(sb, is.begin(), is.end());
        }
      } else {
        size_t replacecount = (jj - ii + step - 1) / step;
        if (is.size() != replacecount) {
          char msg[1024];
          PyOS_snprintf(msg, sizeof(msg), "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
          throw std::invalid_argument(msg);
        }
        typename Sequence::const_iterator isit = is.begin();
        typename Sequence::iterator it = self->begin();
        std::advance(it,ii);
        for (size_t rc=0; rc<replacecount && it != self->end(); ++rc) {
          *it++ = *isit++;
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
        }
      }
    } else {
      size_t replacecount = (ii - jj - step - 1) / -step;
      if (is.size() != replacecount) {
        char msg[1024];
        PyOS_snprintf(msg, sizeof(msg), "attempt to assign sequence of size %lu to extended slice of size %lu", (unsigned long)is.size(), (unsigned long)replacecount);
        throw std::invalid_argument(msg);
      }
      typename Sequence::const_iterator isit = is.begin();
      typename Sequence::reverse_iterator it = self->rbegin();
      std::advance(it,size-ii-1);
      for (size_t rc=0; rc<replacecount && it != self->rend(); ++rc) {
        *it++ = *isit++;
        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
          it++;
      }
    }
  }

  template <class Sequence, class Difference>
  inline void
  delslice(Sequence* self, Difference i, Difference j, Py_ssize_t step) {
    typename Sequence::size_type size = self->size();
    Difference ii = 0;
    Difference jj = 0;
    swig::slice_adjust(i, j, step, size, ii, jj, true);
    if (step > 0) {
      typename Sequence::iterator sb = self->begin();
      std::advance(sb,ii);
      if (step == 1) {
        typename Sequence::iterator se = self->begin();
        std::advance(se,jj);
        self->erase(sb,se);
      } else {
        typename Sequence::iterator it = sb;
        size_t delcount = (jj - ii + step - 1) / step;
        while (delcount) {
          it = self->erase(it);
          for (Py_ssize_t c=0; c<(step-1) && it != self->end(); ++c)
            it++;
          delcount--;
        }
      }
    } else {
      typename Sequence::reverse_iterator sb = self->rbegin();
      std::advance(sb,size-ii-1);
      typename Sequence::reverse_iterator it = sb;
      size_t delcount = (ii - jj - step - 1) / -step;
      while (delcount) {
        it = typename Sequence::reverse_iterator(self->erase((++it).base()));
        for (Py_ssize_t c=0; c<(-step-1) && it != self->rend(); ++c)
          it++;
        delcount--;
      }
    }
  }
}


namespace swig {
  template <class Seq, class T = typename Seq::value_type >
  struct IteratorProtocol {
    static void assign(PyObject *obj, Seq *seq) {
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      if (iter) {
        SwigVar_PyObject item = PyIter_Next(iter);
        while (item) {
          seq->insert(seq->end(), swig::as<T>(item));
          item = PyIter_Next(iter);
        }
      }
    }

    static bool check(PyObject *obj) {
      bool ret = false;
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      if (iter) {
        SwigVar_PyObject item = PyIter_Next(iter);
        ret = true;
        while (item) {
          ret = swig::check<T>(item);
          item = ret ? PyIter_Next(iter) : 0;
        }
      }
      return ret;
    }
  };

  template <class Seq, class T = typename Seq::value_type >
  struct traits_asptr_stdseq {
    typedef Seq sequence;
    typedef T value_type;

    static bool is_iterable(PyObject *obj) {
      SwigVar_PyObject iter = PyObject_GetIter(obj);
      PyErr_Clear();
      return iter != 0;
    }

    static int asptr(PyObject *obj, sequence **seq) {
      int ret = SWIG_ERROR;
      if (obj == Py_None || SWIG_Python_GetSwigThis(obj)) {
	sequence *p;
	swig_type_info *descriptor = swig::type_info<sequence>();
	if (descriptor && SWIG_IsOK(::SWIG_ConvertPtr(obj, (void **)&p, descriptor, 0))) {
	  if (seq) *seq = p;
	  return SWIG_OLDOBJ;
	}
      } else if (is_iterable(obj)) {
	try {
	  if (seq) {
	    *seq = new sequence();
            IteratorProtocol<Seq, T>::assign(obj, *seq);
            if (!PyErr_Occurred())
              return SWIG_NEWOBJ;
	  } else {
	    return IteratorProtocol<Seq, T>::check(obj) ? SWIG_OK : SWIG_ERROR;
	  }
	} catch (std::exception& e) {
          if (seq && !PyErr_Occurred())
            PyErr_SetString(PyExc_TypeError, e.what());
	}
        if (seq)
          delete *seq;
	return SWIG_ERROR;
      }
      return ret;
    }
  };

  template <class Seq, class T = typename Seq::value_type >
  struct traits_from_stdseq {
    typedef Seq sequence;
    typedef T value_type;
    typedef typename Seq::size_type size_type;
    typedef typename sequence::const_iterator const_iterator;

    static PyObject *from(const sequence& seq) {
#ifdef SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS
      swig_type_info *desc = swig::type_info<sequence>();
      if (desc && desc->clientdata) {
	return SWIG_InternalNewPointerObj(new sequence(seq), desc, SWIG_POINTER_OWN);
      }
#endif
      size_type size = seq.size();
      if (size <= (size_type)PY_SSIZE_T_MAX) {
	PyObject *obj = PyTuple_New((Py_ssize_t)size);
	Py_ssize_t i = 0;
	for (const_iterator it = seq.begin(); it != seq.end(); ++it, ++i) {
	  PyTuple_SetItem(obj,i,swig::from<value_type>(*it));
	}
	return obj;
      } else {
	PyErr_SetString(PyExc_OverflowError,"sequence size not valid in python");
	return NULL;
      }
    }
  };
}


  namespace swig {
    template <class T>
    struct traits_reserve<std::vector<T> > {
      static void reserve(std::vector<T> &seq, typename std::vector<T>::size_type n) {
        seq.reserve(n);
      }
    };

    template <class T>
    struct traits_asptr<std::vector<T> >  {
      static int asptr(PyObject *obj, std::vector<T> **vec) {
	return traits_asptr_stdseq<std::vector<T> >::asptr(obj, vec);
      }
    };
    
    template <class T>
    struct traits_from<std::vector<T> > {
      static PyObject *from(const std::vector<T>& vec) {
	return traits_from_stdseq<std::vector<T> >::from(vec);
      }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< int, std::allocator< int > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "int" "," "std::allocator< int >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_int_Sg__iterator(std::vector< int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_int_Sg____nonzero__(std::vector< int > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_int_Sg____bool__(std::vector< int > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< int >::size_type std_vector_Sl_int_Sg____len__(std::vector< int > const *self){
      return self->size();
    }

#ifdef SWIG_LONG_LONG_AVAILABLE
SWIGINTERNINLINE PyObject* 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLongLong(value) : PyInt_FromLong(static_cast< long >(value));
}
#endif


SWIGINTERNINLINE PyObject *
SWIG_From_size_t  (size_t value)
{    
#ifdef SWIG_LONG_LONG_AVAILABLE
  if (sizeof(size_t) <= sizeof(unsigned long)) {
#endif
    return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
#ifdef SWIG_LONG_LONG_AVAILABLE
  } else {
    /* assume sizeof(size_t) <= sizeof(unsigned long long) */
    return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
  }
#endif
}

SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< int,std::allocator< int > >());
    }
SWIGINTERN void std_vector_Sl_int_Sg____setslice____SWIG_1(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j,std::vector< int,std::allocator< int > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delslice__(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_0(std::vector< int > *self,std::vector< int >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< int,std::allocator< int > > *std_vector_Sl_int_Sg____getitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_0(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice,std::vector< int,std::allocator< int > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_int_Sg____delitem____SWIG_1(std::vector< int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< int,std::allocator< int > >::difference_type id = i;
      std::vector< int,std::allocator< int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg____getitem____SWIG_1(std::vector< int > const *self,std::vector< int >::difference_type i){
      return *(swig::cgetpos(self, i));
    }

namespace swig {
  static PyObject* container_owner_attribute() {
    static PyObject* attr = SWIG_Python_str_FromChar("__swig_container");
    return attr;
  }

  template <typename T>
  struct container_owner {
    // By default, do not add the back-reference (for value types)
    // Specialization below will check the reference for pointer types.
    static bool back_reference(PyObject* /*child*/, PyObject* /*owner*/) {
      return false;
    }
  };

  template <>
  struct container_owner<swig::pointer_category> {  
    /*
     * Call to add a back-reference to the owning object when returning a 
     * reference from a container.  Will only set the reference if child
     * is a SWIG wrapper object that does not own the pointer.
     *
     * returns whether the reference was set or not
     */
    static bool back_reference(PyObject* child, PyObject* owner) {
      SwigPyObject* swigThis = SWIG_Python_GetSwigThis(child);
      if (swigThis && (swigThis->own & SWIG_POINTER_OWN) != SWIG_POINTER_OWN) {
        return PyObject_SetAttr(child, container_owner_attribute(), owner) != -1;
      }
      return false;
    }
  };
}

SWIGINTERN void std_vector_Sl_int_Sg____setitem____SWIG_2(std::vector< int > *self,std::vector< int >::difference_type i,std::vector< int >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__pop(std::vector< int > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< int,std::allocator< int > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_int_Sg__append(std::vector< int > *self,std::vector< int >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__erase__SWIG_1(std::vector< int > *self,std::vector< int >::iterator first,std::vector< int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< int >::iterator std_vector_Sl_int_Sg__insert__SWIG_0(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_int_Sg__insert__SWIG_1(std::vector< int > *self,std::vector< int >::iterator pos,std::vector< int >::size_type n,std::vector< int >::value_type const &x){ self->insert(pos, n, x); }

SWIGINTERN int
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UINT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned int >(v);
    }
  }  
  return res;
}


SWIGINTERNINLINE PyObject*
  SWIG_From_unsigned_SS_int  (unsigned int value)
{
  return PyInt_FromSize_t((size_t) value);
}


namespace swig {
  template <> struct traits< unsigned int > {
    typedef value_category category;
    static const char* type_name() { return"unsigned int"; }
  };
  template <>  struct traits_asval< unsigned int > {
    typedef unsigned int value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_unsigned_SS_int (obj, val);
    }
  };
  template <>  struct traits_from< unsigned int > {
    typedef unsigned int value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_unsigned_SS_int  (val);
    }
  };
}


      namespace swig {
	template <>  struct traits<std::vector< unsigned int, std::allocator< unsigned int > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "unsigned int" "," "std::allocator< unsigned int >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_unsigned_SS_int_Sg__iterator(std::vector< unsigned int > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg____nonzero__(std::vector< unsigned int > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg____bool__(std::vector< unsigned int > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< unsigned int >::size_type std_vector_Sl_unsigned_SS_int_Sg____len__(std::vector< unsigned int > const *self){
      return self->size();
    }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *std_vector_Sl_unsigned_SS_int_Sg____getslice__(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< unsigned int,std::allocator< unsigned int > >());
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j,std::vector< unsigned int,std::allocator< unsigned int > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delslice__(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > *std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_0(std::vector< unsigned int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_0(std::vector< unsigned int > *self,SWIGPY_SLICEOBJECT *slice,std::vector< unsigned int,std::allocator< unsigned int > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_1(std::vector< unsigned int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_1(std::vector< unsigned int > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type id = i;
      std::vector< unsigned int,std::allocator< unsigned int > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< unsigned int >::value_type const &std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_1(std::vector< unsigned int > const *self,std::vector< unsigned int >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_2(std::vector< unsigned int > *self,std::vector< unsigned int >::difference_type i,std::vector< unsigned int >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< unsigned int >::value_type std_vector_Sl_unsigned_SS_int_Sg__pop(std::vector< unsigned int > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< unsigned int,std::allocator< unsigned int > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__append(std::vector< unsigned int > *self,std::vector< unsigned int >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator first,std::vector< unsigned int >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< unsigned int >::iterator std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_0(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos,std::vector< unsigned int >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_1(std::vector< unsigned int > *self,std::vector< unsigned int >::iterator pos,std::vector< unsigned int >::size_type n,std::vector< unsigned int >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< unsigned int,std::allocator< unsigned int > >, std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< unsigned int,std::allocator< unsigned int > >" "," "std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__iterator(std::vector< std::vector< unsigned int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____nonzero__(std::vector< std::vector< unsigned int > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____bool__(std::vector< std::vector< unsigned int > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< unsigned int > >::size_type std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____len__(std::vector< std::vector< unsigned int > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____getslice__(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::difference_type i,std::vector< std::vector< unsigned int > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::difference_type i,std::vector< std::vector< unsigned int > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::difference_type i,std::vector< std::vector< unsigned int > >::difference_type j,std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____delslice__(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::difference_type i,std::vector< std::vector< unsigned int > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< unsigned int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type id = i;
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< unsigned int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type id = i;
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< unsigned int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type id = i;
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< unsigned int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type id = i;
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< unsigned int > >::value_type const &std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< unsigned int > > const *self,std::vector< std::vector< unsigned int > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::difference_type i,std::vector< std::vector< unsigned int > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< unsigned int > >::value_type std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__pop(std::vector< std::vector< unsigned int > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__append(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< unsigned int > >::iterator std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__erase__SWIG_0(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< unsigned int > >::iterator std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__erase__SWIG_1(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::iterator first,std::vector< std::vector< unsigned int > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< unsigned int > >::iterator std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__insert__SWIG_0(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::iterator pos,std::vector< std::vector< unsigned int > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__insert__SWIG_1(std::vector< std::vector< unsigned int > > *self,std::vector< std::vector< unsigned int > >::iterator pos,std::vector< std::vector< unsigned int > >::size_type n,std::vector< std::vector< unsigned int > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< double, std::allocator< double > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "double" "," "std::allocator< double >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_double_Sg__iterator(std::vector< double > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_double_Sg____nonzero__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_double_Sg____bool__(std::vector< double > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< double >::size_type std_vector_Sl_double_Sg____len__(std::vector< double > const *self){
      return self->size();
    }
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< double,std::allocator< double > >());
    }
SWIGINTERN void std_vector_Sl_double_Sg____setslice____SWIG_1(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j,std::vector< double,std::allocator< double > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delslice__(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_0(std::vector< double > *self,std::vector< double >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< double,std::allocator< double > > *std_vector_Sl_double_Sg____getitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_0(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice,std::vector< double,std::allocator< double > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_double_Sg____delitem____SWIG_1(std::vector< double > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< double,std::allocator< double > >::difference_type id = i;
      std::vector< double,std::allocator< double > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< double >::value_type const &std_vector_Sl_double_Sg____getitem____SWIG_1(std::vector< double > const *self,std::vector< double >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_double_Sg____setitem____SWIG_2(std::vector< double > *self,std::vector< double >::difference_type i,std::vector< double >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< double >::value_type std_vector_Sl_double_Sg__pop(std::vector< double > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< double,std::allocator< double > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_double_Sg__append(std::vector< double > *self,std::vector< double >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__erase__SWIG_1(std::vector< double > *self,std::vector< double >::iterator first,std::vector< double >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< double >::iterator std_vector_Sl_double_Sg__insert__SWIG_0(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_double_Sg__insert__SWIG_1(std::vector< double > *self,std::vector< double >::iterator pos,std::vector< double >::size_type n,std::vector< double >::value_type const &x){ self->insert(pos, n, x); }

SWIGINTERN int
SWIG_AsPtr_std_string (PyObject * obj, std::string **val) 
{
  char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
  if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
    if (buf) {
      if (val) *val = new std::string(buf, size - 1);
      if (alloc == SWIG_NEWOBJ) delete[] buf;
      return SWIG_NEWOBJ;
    } else {
      if (val) *val = 0;
      return SWIG_OLDOBJ;
    }
  } else {
    PyErr_Clear();
    static swig_type_info *descriptor = SWIG_TypeQuery("std::string" " *");
    if (descriptor) {
      std::string *vptr;
      int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
      if (SWIG_IsOK(res) && val) *val = vptr;
      return res;
    }
  }
  return SWIG_ERROR;
}


SWIGINTERN int
SWIG_AsVal_std_string (PyObject * obj, std::string *val)
{
  std::string* v = (std::string *) 0;
  int res = SWIG_AsPtr_std_string (obj, &v);
  if (!SWIG_IsOK(res)) return res;
  if (v) {
    if (val) *val = *v;
    if (SWIG_IsNewObj(res)) {
      delete v;
      res = SWIG_DelNewMask(res);
    }
    return res;
  }
  return SWIG_ERROR;
}


SWIGINTERNINLINE PyObject *
SWIG_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


namespace swig {
  template <> struct traits< std::string > {
    typedef value_category category;
    static const char* type_name() { return"std::string"; }
  };
  template <>  struct traits_asval< std::string > {
    typedef std::string value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_std_string (obj, val);
    }
  };
  template <>  struct traits_from< std::string > {
    typedef std::string value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_std_string  (val);
    }
  };
}


      namespace swig {
	template <>  struct traits<std::vector< std::string, std::allocator< std::string > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::string" "," "std::allocator< std::string >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_string_Sg__iterator(std::vector< std::string > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____nonzero__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_string_Sg____bool__(std::vector< std::string > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::string >::size_type std_vector_Sl_std_string_Sg____len__(std::vector< std::string > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::string,std::allocator< std::string > >());
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setslice____SWIG_1(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j,std::vector< std::string,std::allocator< std::string > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delslice__(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_0(std::vector< std::string > *self,std::vector< std::string >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > *std_vector_Sl_std_string_Sg____getitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_0(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::string,std::allocator< std::string > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____delitem____SWIG_1(std::vector< std::string > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::string,std::allocator< std::string > >::difference_type id = i;
      std::vector< std::string,std::allocator< std::string > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg____getitem____SWIG_1(std::vector< std::string > const *self,std::vector< std::string >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_string_Sg____setitem____SWIG_2(std::vector< std::string > *self,std::vector< std::string >::difference_type i,std::vector< std::string >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__pop(std::vector< std::string > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::string,std::allocator< std::string > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_string_Sg__append(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__erase__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator first,std::vector< std::string >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::string >::iterator std_vector_Sl_std_string_Sg__insert__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_string_Sg__insert__SWIG_1(std::vector< std::string > *self,std::vector< std::string >::iterator pos,std::vector< std::string >::size_type n,std::vector< std::string >::value_type const &x){ self->insert(pos, n, x); }

SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


SWIGINTERNINLINE PyObject *
SWIG_From_char  (char c) 
{ 
  return SWIG_FromCharPtrAndSize(&c,1);
}


namespace swig {
  template <> struct traits< char > {
    typedef value_category category;
    static const char* type_name() { return"char"; }
  };
  template <>  struct traits_asval< char > {
    typedef char value_type;
    static int asval(PyObject *obj, value_type *val) {
      return SWIG_AsVal_char (obj, val);
    }
  };
  template <>  struct traits_from< char > {
    typedef char value_type;
    static PyObject *from(const value_type& val) {
      return SWIG_From_char  (val);
    }
  };
}


      namespace swig {
	template <>  struct traits<std::vector< char const*, std::allocator< char const * > > > {
	  typedef value_category category;
	  static const char* type_name() {
	    return "std::vector<" "char" " const*," "std::allocator< char const * >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_char_SS_const_Sm__Sg__iterator(std::vector< char const * > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_char_SS_const_Sm__Sg____nonzero__(std::vector< char const * > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_char_SS_const_Sm__Sg____bool__(std::vector< char const * > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< char const * >::size_type std_vector_Sl_char_SS_const_Sm__Sg____len__(std::vector< char const * > const *self){
      return self->size();
    }
SWIGINTERN std::vector< char const *,std::allocator< char const * > > *std_vector_Sl_char_SS_const_Sm__Sg____getslice__(std::vector< char const * > *self,std::vector< char const * >::difference_type i,std::vector< char const * >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____setslice____SWIG_0(std::vector< char const * > *self,std::vector< char const * >::difference_type i,std::vector< char const * >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< char const*,std::allocator< char const * > >());
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____setslice____SWIG_1(std::vector< char const * > *self,std::vector< char const * >::difference_type i,std::vector< char const * >::difference_type j,std::vector< char const *,std::allocator< char const * > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____delslice__(std::vector< char const * > *self,std::vector< char const * >::difference_type i,std::vector< char const * >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____delitem____SWIG_0(std::vector< char const * > *self,std::vector< char const * >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< char const *,std::allocator< char const * > > *std_vector_Sl_char_SS_const_Sm__Sg____getitem____SWIG_0(std::vector< char const * > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< char const*,std::allocator< char const * > >::difference_type id = i;
      std::vector< char const*,std::allocator< char const * > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____setitem____SWIG_0(std::vector< char const * > *self,SWIGPY_SLICEOBJECT *slice,std::vector< char const *,std::allocator< char const * > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< char const*,std::allocator< char const * > >::difference_type id = i;
      std::vector< char const*,std::allocator< char const * > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____setitem____SWIG_1(std::vector< char const * > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< char const*,std::allocator< char const * > >::difference_type id = i;
      std::vector< char const*,std::allocator< char const * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____delitem____SWIG_1(std::vector< char const * > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< char const*,std::allocator< char const * > >::difference_type id = i;
      std::vector< char const*,std::allocator< char const * > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< char const * >::value_type std_vector_Sl_char_SS_const_Sm__Sg____getitem____SWIG_1(std::vector< char const * > *self,std::vector< char const * >::difference_type i){
      return *(swig::cgetpos(self, i));
    }

SWIGINTERNINLINE PyObject * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}




SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg____setitem____SWIG_2(std::vector< char const * > *self,std::vector< char const * >::difference_type i,std::vector< char const * >::value_type x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< char const * >::value_type std_vector_Sl_char_SS_const_Sm__Sg__pop(std::vector< char const * > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< char const*,std::allocator< char const * > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg__append(std::vector< char const * > *self,std::vector< char const * >::value_type x){
      self->push_back(x);
    }
SWIGINTERN std::vector< char const * >::iterator std_vector_Sl_char_SS_const_Sm__Sg__erase__SWIG_0(std::vector< char const * > *self,std::vector< char const * >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< char const * >::iterator std_vector_Sl_char_SS_const_Sm__Sg__erase__SWIG_1(std::vector< char const * > *self,std::vector< char const * >::iterator first,std::vector< char const * >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< char const * >::iterator std_vector_Sl_char_SS_const_Sm__Sg__insert__SWIG_0(std::vector< char const * > *self,std::vector< char const * >::iterator pos,std::vector< char const * >::value_type x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_char_SS_const_Sm__Sg__insert__SWIG_1(std::vector< char const * > *self,std::vector< char const * >::iterator pos,std::vector< char const * >::size_type n,std::vector< char const * >::value_type x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< SOLUTION > {
      typedef pointer_category category;
      static const char* type_name() { return"SOLUTION"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< SOLUTION, std::allocator< SOLUTION > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "SOLUTION" "," "std::allocator< SOLUTION >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_SOLUTION_Sg__iterator(std::vector< SOLUTION > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_SOLUTION_Sg____nonzero__(std::vector< SOLUTION > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_SOLUTION_Sg____bool__(std::vector< SOLUTION > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< SOLUTION >::size_type std_vector_Sl_SOLUTION_Sg____len__(std::vector< SOLUTION > const *self){
      return self->size();
    }
SWIGINTERN std::vector< SOLUTION,std::allocator< SOLUTION > > *std_vector_Sl_SOLUTION_Sg____getslice__(std::vector< SOLUTION > *self,std::vector< SOLUTION >::difference_type i,std::vector< SOLUTION >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____setslice____SWIG_0(std::vector< SOLUTION > *self,std::vector< SOLUTION >::difference_type i,std::vector< SOLUTION >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< SOLUTION,std::allocator< SOLUTION > >());
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____setslice____SWIG_1(std::vector< SOLUTION > *self,std::vector< SOLUTION >::difference_type i,std::vector< SOLUTION >::difference_type j,std::vector< SOLUTION,std::allocator< SOLUTION > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____delslice__(std::vector< SOLUTION > *self,std::vector< SOLUTION >::difference_type i,std::vector< SOLUTION >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____delitem____SWIG_0(std::vector< SOLUTION > *self,std::vector< SOLUTION >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< SOLUTION,std::allocator< SOLUTION > > *std_vector_Sl_SOLUTION_Sg____getitem____SWIG_0(std::vector< SOLUTION > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type id = i;
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____setitem____SWIG_0(std::vector< SOLUTION > *self,SWIGPY_SLICEOBJECT *slice,std::vector< SOLUTION,std::allocator< SOLUTION > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type id = i;
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____setitem____SWIG_1(std::vector< SOLUTION > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type id = i;
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____delitem____SWIG_1(std::vector< SOLUTION > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type id = i;
      std::vector< SOLUTION,std::allocator< SOLUTION > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< SOLUTION >::value_type const &std_vector_Sl_SOLUTION_Sg____getitem____SWIG_1(std::vector< SOLUTION > const *self,std::vector< SOLUTION >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg____setitem____SWIG_2(std::vector< SOLUTION > *self,std::vector< SOLUTION >::difference_type i,std::vector< SOLUTION >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< SOLUTION >::value_type std_vector_Sl_SOLUTION_Sg__pop(std::vector< SOLUTION > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< SOLUTION,std::allocator< SOLUTION > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg__append(std::vector< SOLUTION > *self,std::vector< SOLUTION >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< SOLUTION >::iterator std_vector_Sl_SOLUTION_Sg__erase__SWIG_0(std::vector< SOLUTION > *self,std::vector< SOLUTION >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< SOLUTION >::iterator std_vector_Sl_SOLUTION_Sg__erase__SWIG_1(std::vector< SOLUTION > *self,std::vector< SOLUTION >::iterator first,std::vector< SOLUTION >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< SOLUTION >::iterator std_vector_Sl_SOLUTION_Sg__insert__SWIG_0(std::vector< SOLUTION > *self,std::vector< SOLUTION >::iterator pos,std::vector< SOLUTION >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_SOLUTION_Sg__insert__SWIG_1(std::vector< SOLUTION > *self,std::vector< SOLUTION >::iterator pos,std::vector< SOLUTION >::size_type n,std::vector< SOLUTION >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< COORDINATE > {
      typedef pointer_category category;
      static const char* type_name() { return"COORDINATE"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< COORDINATE, std::allocator< COORDINATE > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "COORDINATE" "," "std::allocator< COORDINATE >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_COORDINATE_Sg__iterator(std::vector< COORDINATE > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_COORDINATE_Sg____nonzero__(std::vector< COORDINATE > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_COORDINATE_Sg____bool__(std::vector< COORDINATE > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< COORDINATE >::size_type std_vector_Sl_COORDINATE_Sg____len__(std::vector< COORDINATE > const *self){
      return self->size();
    }
SWIGINTERN std::vector< COORDINATE,std::allocator< COORDINATE > > *std_vector_Sl_COORDINATE_Sg____getslice__(std::vector< COORDINATE > *self,std::vector< COORDINATE >::difference_type i,std::vector< COORDINATE >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____setslice____SWIG_0(std::vector< COORDINATE > *self,std::vector< COORDINATE >::difference_type i,std::vector< COORDINATE >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< COORDINATE,std::allocator< COORDINATE > >());
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____setslice____SWIG_1(std::vector< COORDINATE > *self,std::vector< COORDINATE >::difference_type i,std::vector< COORDINATE >::difference_type j,std::vector< COORDINATE,std::allocator< COORDINATE > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____delslice__(std::vector< COORDINATE > *self,std::vector< COORDINATE >::difference_type i,std::vector< COORDINATE >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____delitem____SWIG_0(std::vector< COORDINATE > *self,std::vector< COORDINATE >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< COORDINATE,std::allocator< COORDINATE > > *std_vector_Sl_COORDINATE_Sg____getitem____SWIG_0(std::vector< COORDINATE > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type id = i;
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____setitem____SWIG_0(std::vector< COORDINATE > *self,SWIGPY_SLICEOBJECT *slice,std::vector< COORDINATE,std::allocator< COORDINATE > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type id = i;
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____setitem____SWIG_1(std::vector< COORDINATE > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type id = i;
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____delitem____SWIG_1(std::vector< COORDINATE > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type id = i;
      std::vector< COORDINATE,std::allocator< COORDINATE > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< COORDINATE >::value_type const &std_vector_Sl_COORDINATE_Sg____getitem____SWIG_1(std::vector< COORDINATE > const *self,std::vector< COORDINATE >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg____setitem____SWIG_2(std::vector< COORDINATE > *self,std::vector< COORDINATE >::difference_type i,std::vector< COORDINATE >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< COORDINATE >::value_type std_vector_Sl_COORDINATE_Sg__pop(std::vector< COORDINATE > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< COORDINATE,std::allocator< COORDINATE > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg__append(std::vector< COORDINATE > *self,std::vector< COORDINATE >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< COORDINATE >::iterator std_vector_Sl_COORDINATE_Sg__erase__SWIG_0(std::vector< COORDINATE > *self,std::vector< COORDINATE >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< COORDINATE >::iterator std_vector_Sl_COORDINATE_Sg__erase__SWIG_1(std::vector< COORDINATE > *self,std::vector< COORDINATE >::iterator first,std::vector< COORDINATE >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< COORDINATE >::iterator std_vector_Sl_COORDINATE_Sg__insert__SWIG_0(std::vector< COORDINATE > *self,std::vector< COORDINATE >::iterator pos,std::vector< COORDINATE >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_COORDINATE_Sg__insert__SWIG_1(std::vector< COORDINATE > *self,std::vector< COORDINATE >::iterator pos,std::vector< COORDINATE >::size_type n,std::vector< COORDINATE >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< double,std::allocator< double > >, std::allocator< std::vector< double,std::allocator< double > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< double,std::allocator< double > >" "," "std::allocator< std::vector< double,std::allocator< double > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(std::vector< std::vector< double > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__(std::vector< std::vector< double > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__(std::vector< std::vector< double > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< double > >::size_type std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__(std::vector< std::vector< double > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< double > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type id = i;
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< double > >::value_type const &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< double > > const *self,std::vector< std::vector< double > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::difference_type i,std::vector< std::vector< double > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< double > >::value_type std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(std::vector< std::vector< double > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator first,std::vector< std::vector< double > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< double > >::iterator std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(std::vector< std::vector< double > > *self,std::vector< std::vector< double > >::iterator pos,std::vector< std::vector< double > >::size_type n,std::vector< std::vector< double > >::value_type const &x){ self->insert(pos, n, x); }

      namespace swig {
	template <>  struct traits<std::vector< std::vector< int,std::allocator< int > >, std::allocator< std::vector< int,std::allocator< int > > > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "std::vector< int,std::allocator< int > >" "," "std::allocator< std::vector< int,std::allocator< int > > >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_std_vector_Sl_int_Sg__Sg__iterator(std::vector< std::vector< int > > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_int_Sg__Sg____nonzero__(std::vector< std::vector< int > > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_std_vector_Sl_int_Sg__Sg____bool__(std::vector< std::vector< int > > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< std::vector< int > >::size_type std_vector_Sl_std_vector_Sl_int_Sg__Sg____len__(std::vector< std::vector< int > > const *self){
      return self->size();
    }
SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getslice__(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >());
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(std::vector< std::vector< int > > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type id = i;
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< std::vector< int > >::value_type const &std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_1(std::vector< std::vector< int > > const *self,std::vector< std::vector< int > >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_2(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::difference_type i,std::vector< std::vector< int > >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< std::vector< int > >::value_type std_vector_Sl_std_vector_Sl_int_Sg__Sg__pop(std::vector< std::vector< int > > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__append(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator first,std::vector< std::vector< int > >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< std::vector< int > >::iterator std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_0(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos,std::vector< std::vector< int > >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_1(std::vector< std::vector< int > > *self,std::vector< std::vector< int > >::iterator pos,std::vector< std::vector< int > >::size_type n,std::vector< std::vector< int > >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< vrna_ep_t > {
      typedef pointer_category category;
      static const char* type_name() { return"vrna_ep_t"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< vrna_ep_t, std::allocator< vrna_ep_t > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "vrna_ep_t" "," "std::allocator< vrna_ep_t >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_vrna_ep_t_Sg__iterator(std::vector< vrna_ep_t > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_vrna_ep_t_Sg____nonzero__(std::vector< vrna_ep_t > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_vrna_ep_t_Sg____bool__(std::vector< vrna_ep_t > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< vrna_ep_t >::size_type std_vector_Sl_vrna_ep_t_Sg____len__(std::vector< vrna_ep_t > const *self){
      return self->size();
    }
SWIGINTERN std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *std_vector_Sl_vrna_ep_t_Sg____getslice__(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::difference_type i,std::vector< vrna_ep_t >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____setslice____SWIG_0(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::difference_type i,std::vector< vrna_ep_t >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >());
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____setslice____SWIG_1(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::difference_type i,std::vector< vrna_ep_t >::difference_type j,std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____delslice__(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::difference_type i,std::vector< vrna_ep_t >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____delitem____SWIG_0(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *std_vector_Sl_vrna_ep_t_Sg____getitem____SWIG_0(std::vector< vrna_ep_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type id = i;
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____setitem____SWIG_0(std::vector< vrna_ep_t > *self,SWIGPY_SLICEOBJECT *slice,std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type id = i;
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____setitem____SWIG_1(std::vector< vrna_ep_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type id = i;
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____delitem____SWIG_1(std::vector< vrna_ep_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type id = i;
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< vrna_ep_t >::value_type const &std_vector_Sl_vrna_ep_t_Sg____getitem____SWIG_1(std::vector< vrna_ep_t > const *self,std::vector< vrna_ep_t >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg____setitem____SWIG_2(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::difference_type i,std::vector< vrna_ep_t >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< vrna_ep_t >::value_type std_vector_Sl_vrna_ep_t_Sg__pop(std::vector< vrna_ep_t > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg__append(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< vrna_ep_t >::iterator std_vector_Sl_vrna_ep_t_Sg__erase__SWIG_0(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< vrna_ep_t >::iterator std_vector_Sl_vrna_ep_t_Sg__erase__SWIG_1(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::iterator first,std::vector< vrna_ep_t >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< vrna_ep_t >::iterator std_vector_Sl_vrna_ep_t_Sg__insert__SWIG_0(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::iterator pos,std::vector< vrna_ep_t >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_vrna_ep_t_Sg__insert__SWIG_1(std::vector< vrna_ep_t > *self,std::vector< vrna_ep_t >::iterator pos,std::vector< vrna_ep_t >::size_type n,std::vector< vrna_ep_t >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< vrna_hx_t > {
      typedef pointer_category category;
      static const char* type_name() { return"vrna_hx_t"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< vrna_hx_t, std::allocator< vrna_hx_t > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "vrna_hx_t" "," "std::allocator< vrna_hx_t >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_vrna_hx_t_Sg__iterator(std::vector< vrna_hx_t > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_vrna_hx_t_Sg____nonzero__(std::vector< vrna_hx_t > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_vrna_hx_t_Sg____bool__(std::vector< vrna_hx_t > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< vrna_hx_t >::size_type std_vector_Sl_vrna_hx_t_Sg____len__(std::vector< vrna_hx_t > const *self){
      return self->size();
    }
SWIGINTERN std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *std_vector_Sl_vrna_hx_t_Sg____getslice__(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::difference_type i,std::vector< vrna_hx_t >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____setslice____SWIG_0(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::difference_type i,std::vector< vrna_hx_t >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >());
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____setslice____SWIG_1(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::difference_type i,std::vector< vrna_hx_t >::difference_type j,std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____delslice__(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::difference_type i,std::vector< vrna_hx_t >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____delitem____SWIG_0(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *std_vector_Sl_vrna_hx_t_Sg____getitem____SWIG_0(std::vector< vrna_hx_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type id = i;
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____setitem____SWIG_0(std::vector< vrna_hx_t > *self,SWIGPY_SLICEOBJECT *slice,std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type id = i;
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____setitem____SWIG_1(std::vector< vrna_hx_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type id = i;
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____delitem____SWIG_1(std::vector< vrna_hx_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type id = i;
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< vrna_hx_t >::value_type const &std_vector_Sl_vrna_hx_t_Sg____getitem____SWIG_1(std::vector< vrna_hx_t > const *self,std::vector< vrna_hx_t >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg____setitem____SWIG_2(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::difference_type i,std::vector< vrna_hx_t >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< vrna_hx_t >::value_type std_vector_Sl_vrna_hx_t_Sg__pop(std::vector< vrna_hx_t > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg__append(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< vrna_hx_t >::iterator std_vector_Sl_vrna_hx_t_Sg__erase__SWIG_0(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< vrna_hx_t >::iterator std_vector_Sl_vrna_hx_t_Sg__erase__SWIG_1(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::iterator first,std::vector< vrna_hx_t >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< vrna_hx_t >::iterator std_vector_Sl_vrna_hx_t_Sg__insert__SWIG_0(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::iterator pos,std::vector< vrna_hx_t >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_vrna_hx_t_Sg__insert__SWIG_1(std::vector< vrna_hx_t > *self,std::vector< vrna_hx_t >::iterator pos,std::vector< vrna_hx_t >::size_type n,std::vector< vrna_hx_t >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< vrna_path_t > {
      typedef pointer_category category;
      static const char* type_name() { return"vrna_path_t"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< vrna_path_t, std::allocator< vrna_path_t > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "vrna_path_t" "," "std::allocator< vrna_path_t >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_vrna_path_t_Sg__iterator(std::vector< vrna_path_t > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_vrna_path_t_Sg____nonzero__(std::vector< vrna_path_t > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_vrna_path_t_Sg____bool__(std::vector< vrna_path_t > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< vrna_path_t >::size_type std_vector_Sl_vrna_path_t_Sg____len__(std::vector< vrna_path_t > const *self){
      return self->size();
    }
SWIGINTERN std::vector< vrna_path_t,std::allocator< vrna_path_t > > *std_vector_Sl_vrna_path_t_Sg____getslice__(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::difference_type i,std::vector< vrna_path_t >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____setslice____SWIG_0(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::difference_type i,std::vector< vrna_path_t >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< vrna_path_t,std::allocator< vrna_path_t > >());
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____setslice____SWIG_1(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::difference_type i,std::vector< vrna_path_t >::difference_type j,std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____delslice__(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::difference_type i,std::vector< vrna_path_t >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____delitem____SWIG_0(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< vrna_path_t,std::allocator< vrna_path_t > > *std_vector_Sl_vrna_path_t_Sg____getitem____SWIG_0(std::vector< vrna_path_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type id = i;
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____setitem____SWIG_0(std::vector< vrna_path_t > *self,SWIGPY_SLICEOBJECT *slice,std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type id = i;
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____setitem____SWIG_1(std::vector< vrna_path_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type id = i;
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____delitem____SWIG_1(std::vector< vrna_path_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type id = i;
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< vrna_path_t >::value_type const &std_vector_Sl_vrna_path_t_Sg____getitem____SWIG_1(std::vector< vrna_path_t > const *self,std::vector< vrna_path_t >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg____setitem____SWIG_2(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::difference_type i,std::vector< vrna_path_t >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< vrna_path_t >::value_type std_vector_Sl_vrna_path_t_Sg__pop(std::vector< vrna_path_t > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< vrna_path_t,std::allocator< vrna_path_t > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg__append(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< vrna_path_t >::iterator std_vector_Sl_vrna_path_t_Sg__erase__SWIG_0(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< vrna_path_t >::iterator std_vector_Sl_vrna_path_t_Sg__erase__SWIG_1(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::iterator first,std::vector< vrna_path_t >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< vrna_path_t >::iterator std_vector_Sl_vrna_path_t_Sg__insert__SWIG_0(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::iterator pos,std::vector< vrna_path_t >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_vrna_path_t_Sg__insert__SWIG_1(std::vector< vrna_path_t > *self,std::vector< vrna_path_t >::iterator pos,std::vector< vrna_path_t >::size_type n,std::vector< vrna_path_t >::value_type const &x){ self->insert(pos, n, x); }

  namespace swig {
    template <>  struct traits< vrna_move_t > {
      typedef pointer_category category;
      static const char* type_name() { return"vrna_move_t"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< vrna_move_t, std::allocator< vrna_move_t > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "vrna_move_t" "," "std::allocator< vrna_move_t >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_vrna_move_t_Sg__iterator(std::vector< vrna_move_t > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_vrna_move_t_Sg____nonzero__(std::vector< vrna_move_t > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_vrna_move_t_Sg____bool__(std::vector< vrna_move_t > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< vrna_move_t >::size_type std_vector_Sl_vrna_move_t_Sg____len__(std::vector< vrna_move_t > const *self){
      return self->size();
    }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > *std_vector_Sl_vrna_move_t_Sg____getslice__(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::difference_type i,std::vector< vrna_move_t >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____setslice____SWIG_0(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::difference_type i,std::vector< vrna_move_t >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< vrna_move_t,std::allocator< vrna_move_t > >());
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____setslice____SWIG_1(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::difference_type i,std::vector< vrna_move_t >::difference_type j,std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____delslice__(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::difference_type i,std::vector< vrna_move_t >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____delitem____SWIG_0(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > *std_vector_Sl_vrna_move_t_Sg____getitem____SWIG_0(std::vector< vrna_move_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type id = i;
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____setitem____SWIG_0(std::vector< vrna_move_t > *self,SWIGPY_SLICEOBJECT *slice,std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type id = i;
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____setitem____SWIG_1(std::vector< vrna_move_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type id = i;
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____delitem____SWIG_1(std::vector< vrna_move_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type id = i;
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< vrna_move_t >::value_type const &std_vector_Sl_vrna_move_t_Sg____getitem____SWIG_1(std::vector< vrna_move_t > const *self,std::vector< vrna_move_t >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg____setitem____SWIG_2(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::difference_type i,std::vector< vrna_move_t >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< vrna_move_t >::value_type std_vector_Sl_vrna_move_t_Sg__pop(std::vector< vrna_move_t > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< vrna_move_t,std::allocator< vrna_move_t > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg__append(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< vrna_move_t >::iterator std_vector_Sl_vrna_move_t_Sg__erase__SWIG_0(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< vrna_move_t >::iterator std_vector_Sl_vrna_move_t_Sg__erase__SWIG_1(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::iterator first,std::vector< vrna_move_t >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< vrna_move_t >::iterator std_vector_Sl_vrna_move_t_Sg__insert__SWIG_0(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::iterator pos,std::vector< vrna_move_t >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_vrna_move_t_Sg__insert__SWIG_1(std::vector< vrna_move_t > *self,std::vector< vrna_move_t >::iterator pos,std::vector< vrna_move_t >::size_type n,std::vector< vrna_move_t >::value_type const &x){ self->insert(pos, n, x); }

#include <string>
#include <cstring>

  const char *convert_vecstring2veccharcp(const std::string & s){
    return s.c_str();
  }

  char *convert_vecstring2veccharp(const std::string & s){
    char *pc = new char[s.size()+1];
    std::strcpy(pc, s.c_str());
    return pc;
  }
  
  short convert_vecint2vecshort(const int & i){
    return (short) i;
  }

  FLT_OR_DBL convert_vecdbl2vecFLR_OR_DBL(const double & d){
    return (FLT_OR_DBL) d;
  }



#ifdef _WIN32
#ifdef __MINGW32__
#include <unistd.h>
#else
#include "ViennaRNA/intern/unistd_win.h"
#endif
#else
#include <unistd.h>
#endif



#ifdef SWIGPYTHON
# ifndef SWIGPY_SLICEOBJECT
#   if PY_VERSION_HEX >= 0x03020000
#     define SWIGPY_SLICEOBJECT PyObject
#   else
#     define SWIGPY_SLICEOBJECT PySliceObject
#   endif
# endif
#endif

#include <sstream>

#define VAR_ARRAY_LINEAR      1U
#define VAR_ARRAY_TRI         2U
#define VAR_ARRAY_SQR         4U
#define VAR_ARRAY_ONE_BASED   8U
#define VAR_ARRAY_OWNED       16U

template <typename T>
struct var_array {
  size_t        length;
  T             *data;
  unsigned int  type;
};


template <typename T>
std::string
var_array_type_str(var_array<T> *a)
{
  std::ostringstream out;

  if (a->type & VAR_ARRAY_LINEAR)
    out << "RNA.VAR_ARRAY_LINEAR";
  else  if (a->type & VAR_ARRAY_TRI)
    out << "RNA.VAR_ARRAY_TRI";
  else  if (a->type & VAR_ARRAY_SQR)
    out << "RNA.VAR_ARRAY_SQR";

  if (a->type & VAR_ARRAY_ONE_BASED)
    out << " | RNA.VAR_ARRAY_ONE_BASED";

  return std::string(out.str());
}


/* determine length n given array_size elements of the respective
   upper triangular square matrix. Here, we assume that the largest
   entry in the array resides at position (n*(n-1))/2 + n. So the
   actual size of the array is (n*(n-1))/2 + n + 1, since arrays 
   are always 0-based
*/
inline size_t
var_array_tri_size(size_t array_size)
{
  return (size_t)floor((sqrt(8 * array_size - 7) - 1) / 2);
}


/* compute number of entries in the upper-triangular n*n square
   matrix with dimension n
*/
inline size_t
var_array_data_size_tri(size_t n)
{
  return (n * (n - 1)) / 2 + n + 1;
}


/* determine length n given array_size elements of the respective
   square matrix
*/
inline size_t
var_array_sqr_size(size_t array_size)
{
  return (size_t)(sqrt(array_size - 1));
}


/* compute number of entries in the n*n square
   matrix with dimension n
*/
inline size_t
var_array_data_size_sqr(size_t n)
{
  return n * n + 1;
}


/****************/
/* Constructors */
/****************/
template <typename T>
inline var_array<T> *
var_array_new(size_t        length,
              T             *data,
              unsigned int  type)
{
  var_array<T> *a = NULL;

  if ((length) &&
      (data)) {
    a         = (var_array<T> *)vrna_alloc(sizeof(var_array<T>));
    a->length = length;
    a->data   = data;
    a->type   = type;
  }

  return a;
}


SWIGINTERN var_array< unsigned char > *new_var_array_Sl_unsigned_SS_char_Sg_(std::vector< unsigned char,std::allocator< unsigned char > > d,unsigned int type){
    var_array<unsigned char> *a = NULL;
    size_t        n = d.size();

    if (n > 0) {
      a = (var_array<unsigned char> *)vrna_alloc(sizeof(var_array<unsigned char>));
      a->data   = (unsigned char *)vrna_alloc(sizeof(unsigned char) * n);
      memcpy(a->data, &(d[0]), sizeof(unsigned char) * n);

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a->length = n;
      a->type   = type | VAR_ARRAY_OWNED;
    }

    return a;
  }
SWIGINTERN void delete_var_array_Sl_unsigned_SS_char_Sg_(var_array< unsigned char > *self){
    if (self->type & VAR_ARRAY_OWNED)
      free(self->data);
    free(self);
  }
SWIGINTERN std::string var_array_Sl_unsigned_SS_char_Sg__type(var_array< unsigned char > *self){
    std::ostringstream out;

    if (self->type & VAR_ARRAY_LINEAR)
      out << "RNA.VAR_ARRAY_LINEAR";
    else  if (self->type & VAR_ARRAY_TRI)
      out << "RNA.VAR_ARRAY_TRI";
    else  if (self->type & VAR_ARRAY_SQR)
      out << "RNA.VAR_ARRAY_SQR";

    if (self->type & VAR_ARRAY_ONE_BASED)
      out << " | RNA.VAR_ARRAY_ONE_BASED";

    return std::string(out.str());
  }
SWIGINTERN size_t var_array_Sl_unsigned_SS_char_Sg__size(var_array< unsigned char > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN size_t var_array_Sl_unsigned_SS_char_Sg____len__(var_array< unsigned char > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN unsigned char const var_array_Sl_unsigned_SS_char_Sg__get(var_array< unsigned char > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && (-i >= max_i)) ||
        ((i >= 0) && (i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }

SWIGINTERNINLINE PyObject *
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}

SWIGINTERN unsigned char const var_array_Sl_unsigned_SS_char_Sg____getitem____SWIG_0(var_array< unsigned char > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }

SWIGINTERN int
SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
{
  unsigned long v;
  int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v > UCHAR_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = static_cast< unsigned char >(v);
    }
  }  
  return res;
}

SWIGINTERN unsigned char const var_array_Sl_unsigned_SS_char_Sg____setitem__(var_array< unsigned char > const *self,int i,unsigned char const d){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i] = d;
  }
SWIGINTERN var_array< unsigned char > *var_array_Sl_unsigned_SS_char_Sg____getitem____SWIG_1(var_array< unsigned char > *self,SWIGPY_SLICEOBJECT *ob){
    size_t        n, real_i, max_i;
    unsigned int  type;
    Py_ssize_t    start, stop, step, slice_l, l;
    var_array<unsigned char>  *a;

    if (PySlice_Check(ob)) {
      a = NULL;
      max_i = self->length;

      if (self->type & VAR_ARRAY_ONE_BASED)
        max_i += 1;

      if (self->type & VAR_ARRAY_TRI)
        max_i = var_array_data_size_tri(max_i - 1);
      else if (self->type & VAR_ARRAY_SQR)
        max_i = var_array_data_size_sqr(max_i);

      l = max_i;


      if (PySlice_GetIndicesEx(ob, l, &start, &stop, &step, &slice_l) == 0) {
        real_i  = 0;
        type    = self->type;
        n       = slice_l;

        if ((type & VAR_ARRAY_LINEAR) &&
            (type & VAR_ARRAY_ONE_BASED) &&
            (start != 0))
          type &= ~VAR_ARRAY_ONE_BASED;

        if (n > 0) {
          a = (var_array<unsigned char> *)vrna_alloc(sizeof(var_array<unsigned char>));
          a->data   = (unsigned char *)vrna_alloc(sizeof(unsigned char) * n);
          /* copy slice data */
          for (Py_ssize_t i = start; i < stop; i += step, real_i++)
            a->data[real_i] = self->data[i];

          if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED)) {
            n -= 1;
            a->data[0] = n;
          }

          a->length = n;
          a->type   = type | VAR_ARRAY_OWNED;
        }
      } else {
        return NULL;
      }

    } else {
      PyErr_SetString(PyExc_TypeError, "Expected integer or slice object");
      return 0;
    }

    return a;
  }
SWIGINTERN var_array< char > *new_var_array_Sl_char_Sg_(std::vector< char,std::allocator< char > > d,unsigned int type){
    var_array<char> *a = NULL;
    size_t        n = d.size();

    if (n > 0) {
      a = (var_array<char> *)vrna_alloc(sizeof(var_array<char>));
      a->data   = (char *)vrna_alloc(sizeof(char) * n);
      memcpy(a->data, &(d[0]), sizeof(char) * n);

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a->length = n;
      a->type   = type | VAR_ARRAY_OWNED;
    }

    return a;
  }
SWIGINTERN void delete_var_array_Sl_char_Sg_(var_array< char > *self){
    if (self->type & VAR_ARRAY_OWNED)
      free(self->data);
    free(self);
  }
SWIGINTERN std::string var_array_Sl_char_Sg__type(var_array< char > *self){
    std::ostringstream out;

    if (self->type & VAR_ARRAY_LINEAR)
      out << "RNA.VAR_ARRAY_LINEAR";
    else  if (self->type & VAR_ARRAY_TRI)
      out << "RNA.VAR_ARRAY_TRI";
    else  if (self->type & VAR_ARRAY_SQR)
      out << "RNA.VAR_ARRAY_SQR";

    if (self->type & VAR_ARRAY_ONE_BASED)
      out << " | RNA.VAR_ARRAY_ONE_BASED";

    return std::string(out.str());
  }
SWIGINTERN size_t var_array_Sl_char_Sg__size(var_array< char > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN size_t var_array_Sl_char_Sg____len__(var_array< char > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN char const var_array_Sl_char_Sg__get(var_array< char > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && (-i >= max_i)) ||
        ((i >= 0) && (i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN char const var_array_Sl_char_Sg____getitem____SWIG_0(var_array< char > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN char const var_array_Sl_char_Sg____setitem__(var_array< char > const *self,int i,char const d){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i] = d;
  }
SWIGINTERN var_array< char > *var_array_Sl_char_Sg____getitem____SWIG_1(var_array< char > *self,SWIGPY_SLICEOBJECT *ob){
    size_t        n, real_i, max_i;
    unsigned int  type;
    Py_ssize_t    start, stop, step, slice_l, l;
    var_array<char>  *a;

    if (PySlice_Check(ob)) {
      a = NULL;
      max_i = self->length;

      if (self->type & VAR_ARRAY_ONE_BASED)
        max_i += 1;

      if (self->type & VAR_ARRAY_TRI)
        max_i = var_array_data_size_tri(max_i - 1);
      else if (self->type & VAR_ARRAY_SQR)
        max_i = var_array_data_size_sqr(max_i);

      l = max_i;


      if (PySlice_GetIndicesEx(ob, l, &start, &stop, &step, &slice_l) == 0) {
        real_i  = 0;
        type    = self->type;
        n       = slice_l;

        if ((type & VAR_ARRAY_LINEAR) &&
            (type & VAR_ARRAY_ONE_BASED) &&
            (start != 0))
          type &= ~VAR_ARRAY_ONE_BASED;

        if (n > 0) {
          a = (var_array<char> *)vrna_alloc(sizeof(var_array<char>));
          a->data   = (char *)vrna_alloc(sizeof(char) * n);
          /* copy slice data */
          for (Py_ssize_t i = start; i < stop; i += step, real_i++)
            a->data[real_i] = self->data[i];

          if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED)) {
            n -= 1;
            a->data[0] = n;
          }

          a->length = n;
          a->type   = type | VAR_ARRAY_OWNED;
        }
      } else {
        return NULL;
      }

    } else {
      PyErr_SetString(PyExc_TypeError, "Expected integer or slice object");
      return 0;
    }

    return a;
  }
SWIGINTERN var_array< short > *new_var_array_Sl_short_Sg___SWIG_0(std::vector< short,std::allocator< short > > d,unsigned int type){
    var_array<short> *a = NULL;
    size_t        n = d.size();

    if (n > 0) {
      a = (var_array<short> *)vrna_alloc(sizeof(var_array<short>));
      a->data   = (short *)vrna_alloc(sizeof(short) * n);
      memcpy(a->data, &(d[0]), sizeof(short) * n);

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a->length = n;
      a->type   = type | VAR_ARRAY_OWNED;
    }

    return a;
  }
SWIGINTERN void delete_var_array_Sl_short_Sg_(var_array< short > *self){
    if (self->type & VAR_ARRAY_OWNED)
      free(self->data);
    free(self);
  }
SWIGINTERN std::string var_array_Sl_short_Sg__type(var_array< short > *self){
    std::ostringstream out;

    if (self->type & VAR_ARRAY_LINEAR)
      out << "RNA.VAR_ARRAY_LINEAR";
    else  if (self->type & VAR_ARRAY_TRI)
      out << "RNA.VAR_ARRAY_TRI";
    else  if (self->type & VAR_ARRAY_SQR)
      out << "RNA.VAR_ARRAY_SQR";

    if (self->type & VAR_ARRAY_ONE_BASED)
      out << " | RNA.VAR_ARRAY_ONE_BASED";

    return std::string(out.str());
  }
SWIGINTERN size_t var_array_Sl_short_Sg__size(var_array< short > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN size_t var_array_Sl_short_Sg____len__(var_array< short > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN short const var_array_Sl_short_Sg__get(var_array< short > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && (-i >= max_i)) ||
        ((i >= 0) && (i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN short const var_array_Sl_short_Sg____getitem____SWIG_0(var_array< short > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN short const var_array_Sl_short_Sg____setitem__(var_array< short > const *self,int i,short const d){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i] = d;
  }
SWIGINTERN var_array< short > *new_var_array_Sl_short_Sg___SWIG_1(std::vector< int,std::allocator< int > > data,unsigned int type=VAR_ARRAY_LINEAR|VAR_ARRAY_ONE_BASED){
    var_array<short> *a = NULL;
    size_t        n = data.size();

    if (n > 0) {
      short *data_s   = (short *)vrna_alloc(sizeof(short) * n);

      for (size_t i = 0; i < n; i++)
        data_s[i] = (short)data[i];

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a = var_array_new(n, data_s, type | VAR_ARRAY_OWNED);
    }

    return a;
  }
SWIGINTERN var_array< short > *var_array_Sl_short_Sg____getitem____SWIG_1(var_array< short > *self,SWIGPY_SLICEOBJECT *ob){
    size_t        n, real_i, max_i;
    unsigned int  type;
    Py_ssize_t    start, stop, step, slice_l, l;
    var_array<short>  *a;

    if (PySlice_Check(ob)) {
      a = NULL;
      max_i = self->length;

      if (self->type & VAR_ARRAY_ONE_BASED)
        max_i += 1;

      if (self->type & VAR_ARRAY_TRI)
        max_i = var_array_data_size_tri(max_i - 1);
      else if (self->type & VAR_ARRAY_SQR)
        max_i = var_array_data_size_sqr(max_i);

      l = max_i;


      if (PySlice_GetIndicesEx(ob, l, &start, &stop, &step, &slice_l) == 0) {
        real_i  = 0;
        type    = self->type;
        n       = slice_l;

        if ((type & VAR_ARRAY_LINEAR) &&
            (type & VAR_ARRAY_ONE_BASED) &&
            (start != 0))
          type &= ~VAR_ARRAY_ONE_BASED;

        if (n > 0) {
          a = (var_array<short> *)vrna_alloc(sizeof(var_array<short>));
          a->data   = (short *)vrna_alloc(sizeof(short) * n);
          /* copy slice data */
          for (Py_ssize_t i = start; i < stop; i += step, real_i++)
            a->data[real_i] = self->data[i];

          if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED)) {
            n -= 1;
            a->data[0] = n;
          }

          a->length = n;
          a->type   = type | VAR_ARRAY_OWNED;
        }
      } else {
        return NULL;
      }

    } else {
      PyErr_SetString(PyExc_TypeError, "Expected integer or slice object");
      return 0;
    }

    return a;
  }
SWIGINTERN var_array< unsigned int > *new_var_array_Sl_unsigned_SS_int_Sg_(std::vector< unsigned int,std::allocator< unsigned int > > d,unsigned int type){
    var_array<unsigned int> *a = NULL;
    size_t        n = d.size();

    if (n > 0) {
      a = (var_array<unsigned int> *)vrna_alloc(sizeof(var_array<unsigned int>));
      a->data   = (unsigned int *)vrna_alloc(sizeof(unsigned int) * n);
      memcpy(a->data, &(d[0]), sizeof(unsigned int) * n);

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a->length = n;
      a->type   = type | VAR_ARRAY_OWNED;
    }

    return a;
  }
SWIGINTERN void delete_var_array_Sl_unsigned_SS_int_Sg_(var_array< unsigned int > *self){
    if (self->type & VAR_ARRAY_OWNED)
      free(self->data);
    free(self);
  }
SWIGINTERN std::string var_array_Sl_unsigned_SS_int_Sg__type(var_array< unsigned int > *self){
    std::ostringstream out;

    if (self->type & VAR_ARRAY_LINEAR)
      out << "RNA.VAR_ARRAY_LINEAR";
    else  if (self->type & VAR_ARRAY_TRI)
      out << "RNA.VAR_ARRAY_TRI";
    else  if (self->type & VAR_ARRAY_SQR)
      out << "RNA.VAR_ARRAY_SQR";

    if (self->type & VAR_ARRAY_ONE_BASED)
      out << " | RNA.VAR_ARRAY_ONE_BASED";

    return std::string(out.str());
  }
SWIGINTERN size_t var_array_Sl_unsigned_SS_int_Sg__size(var_array< unsigned int > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN size_t var_array_Sl_unsigned_SS_int_Sg____len__(var_array< unsigned int > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN unsigned int const var_array_Sl_unsigned_SS_int_Sg__get(var_array< unsigned int > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && (-i >= max_i)) ||
        ((i >= 0) && (i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN unsigned int const var_array_Sl_unsigned_SS_int_Sg____getitem____SWIG_0(var_array< unsigned int > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN unsigned int const var_array_Sl_unsigned_SS_int_Sg____setitem__(var_array< unsigned int > const *self,int i,unsigned int const d){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i] = d;
  }
SWIGINTERN var_array< unsigned int > *var_array_Sl_unsigned_SS_int_Sg____getitem____SWIG_1(var_array< unsigned int > *self,SWIGPY_SLICEOBJECT *ob){
    size_t        n, real_i, max_i;
    unsigned int  type;
    Py_ssize_t    start, stop, step, slice_l, l;
    var_array<unsigned int>  *a;

    if (PySlice_Check(ob)) {
      a = NULL;
      max_i = self->length;

      if (self->type & VAR_ARRAY_ONE_BASED)
        max_i += 1;

      if (self->type & VAR_ARRAY_TRI)
        max_i = var_array_data_size_tri(max_i - 1);
      else if (self->type & VAR_ARRAY_SQR)
        max_i = var_array_data_size_sqr(max_i);

      l = max_i;


      if (PySlice_GetIndicesEx(ob, l, &start, &stop, &step, &slice_l) == 0) {
        real_i  = 0;
        type    = self->type;
        n       = slice_l;

        if ((type & VAR_ARRAY_LINEAR) &&
            (type & VAR_ARRAY_ONE_BASED) &&
            (start != 0))
          type &= ~VAR_ARRAY_ONE_BASED;

        if (n > 0) {
          a = (var_array<unsigned int> *)vrna_alloc(sizeof(var_array<unsigned int>));
          a->data   = (unsigned int *)vrna_alloc(sizeof(unsigned int) * n);
          /* copy slice data */
          for (Py_ssize_t i = start; i < stop; i += step, real_i++)
            a->data[real_i] = self->data[i];

          if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED)) {
            n -= 1;
            a->data[0] = n;
          }

          a->length = n;
          a->type   = type | VAR_ARRAY_OWNED;
        }
      } else {
        return NULL;
      }

    } else {
      PyErr_SetString(PyExc_TypeError, "Expected integer or slice object");
      return 0;
    }

    return a;
  }
SWIGINTERN var_array< int > *new_var_array_Sl_int_Sg_(std::vector< int,std::allocator< int > > d,unsigned int type){
    var_array<int> *a = NULL;
    size_t        n = d.size();

    if (n > 0) {
      a = (var_array<int> *)vrna_alloc(sizeof(var_array<int>));
      a->data   = (int *)vrna_alloc(sizeof(int) * n);
      memcpy(a->data, &(d[0]), sizeof(int) * n);

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a->length = n;
      a->type   = type | VAR_ARRAY_OWNED;
    }

    return a;
  }
SWIGINTERN void delete_var_array_Sl_int_Sg_(var_array< int > *self){
    if (self->type & VAR_ARRAY_OWNED)
      free(self->data);
    free(self);
  }
SWIGINTERN std::string var_array_Sl_int_Sg__type(var_array< int > *self){
    std::ostringstream out;

    if (self->type & VAR_ARRAY_LINEAR)
      out << "RNA.VAR_ARRAY_LINEAR";
    else  if (self->type & VAR_ARRAY_TRI)
      out << "RNA.VAR_ARRAY_TRI";
    else  if (self->type & VAR_ARRAY_SQR)
      out << "RNA.VAR_ARRAY_SQR";

    if (self->type & VAR_ARRAY_ONE_BASED)
      out << " | RNA.VAR_ARRAY_ONE_BASED";

    return std::string(out.str());
  }
SWIGINTERN size_t var_array_Sl_int_Sg__size(var_array< int > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN size_t var_array_Sl_int_Sg____len__(var_array< int > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN int const var_array_Sl_int_Sg__get(var_array< int > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && (-i >= max_i)) ||
        ((i >= 0) && (i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN int const var_array_Sl_int_Sg____getitem____SWIG_0(var_array< int > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN int const var_array_Sl_int_Sg____setitem__(var_array< int > const *self,int i,int const d){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i] = d;
  }
SWIGINTERN var_array< int > *var_array_Sl_int_Sg____getitem____SWIG_1(var_array< int > *self,SWIGPY_SLICEOBJECT *ob){
    size_t        n, real_i, max_i;
    unsigned int  type;
    Py_ssize_t    start, stop, step, slice_l, l;
    var_array<int>  *a;

    if (PySlice_Check(ob)) {
      a = NULL;
      max_i = self->length;

      if (self->type & VAR_ARRAY_ONE_BASED)
        max_i += 1;

      if (self->type & VAR_ARRAY_TRI)
        max_i = var_array_data_size_tri(max_i - 1);
      else if (self->type & VAR_ARRAY_SQR)
        max_i = var_array_data_size_sqr(max_i);

      l = max_i;


      if (PySlice_GetIndicesEx(ob, l, &start, &stop, &step, &slice_l) == 0) {
        real_i  = 0;
        type    = self->type;
        n       = slice_l;

        if ((type & VAR_ARRAY_LINEAR) &&
            (type & VAR_ARRAY_ONE_BASED) &&
            (start != 0))
          type &= ~VAR_ARRAY_ONE_BASED;

        if (n > 0) {
          a = (var_array<int> *)vrna_alloc(sizeof(var_array<int>));
          a->data   = (int *)vrna_alloc(sizeof(int) * n);
          /* copy slice data */
          for (Py_ssize_t i = start; i < stop; i += step, real_i++)
            a->data[real_i] = self->data[i];

          if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED)) {
            n -= 1;
            a->data[0] = n;
          }

          a->length = n;
          a->type   = type | VAR_ARRAY_OWNED;
        }
      } else {
        return NULL;
      }

    } else {
      PyErr_SetString(PyExc_TypeError, "Expected integer or slice object");
      return 0;
    }

    return a;
  }
SWIGINTERN var_array< FLT_OR_DBL > *new_var_array_Sl_FLT_OR_DBL_Sg_(std::vector< FLT_OR_DBL,std::allocator< FLT_OR_DBL > > d,unsigned int type){
    var_array<FLT_OR_DBL> *a = NULL;
    size_t        n = d.size();

    if (n > 0) {
      a = (var_array<FLT_OR_DBL> *)vrna_alloc(sizeof(var_array<FLT_OR_DBL>));
      a->data   = (FLT_OR_DBL *)vrna_alloc(sizeof(FLT_OR_DBL) * n);
      memcpy(a->data, &(d[0]), sizeof(FLT_OR_DBL) * n);

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a->length = n;
      a->type   = type | VAR_ARRAY_OWNED;
    }

    return a;
  }
SWIGINTERN void delete_var_array_Sl_FLT_OR_DBL_Sg_(var_array< FLT_OR_DBL > *self){
    if (self->type & VAR_ARRAY_OWNED)
      free(self->data);
    free(self);
  }
SWIGINTERN std::string var_array_Sl_FLT_OR_DBL_Sg__type(var_array< FLT_OR_DBL > *self){
    std::ostringstream out;

    if (self->type & VAR_ARRAY_LINEAR)
      out << "RNA.VAR_ARRAY_LINEAR";
    else  if (self->type & VAR_ARRAY_TRI)
      out << "RNA.VAR_ARRAY_TRI";
    else  if (self->type & VAR_ARRAY_SQR)
      out << "RNA.VAR_ARRAY_SQR";

    if (self->type & VAR_ARRAY_ONE_BASED)
      out << " | RNA.VAR_ARRAY_ONE_BASED";

    return std::string(out.str());
  }
SWIGINTERN size_t var_array_Sl_FLT_OR_DBL_Sg__size(var_array< FLT_OR_DBL > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN size_t var_array_Sl_FLT_OR_DBL_Sg____len__(var_array< FLT_OR_DBL > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN FLT_OR_DBL const var_array_Sl_FLT_OR_DBL_Sg__get(var_array< FLT_OR_DBL > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && (-i >= max_i)) ||
        ((i >= 0) && (i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN FLT_OR_DBL const var_array_Sl_FLT_OR_DBL_Sg____getitem____SWIG_0(var_array< FLT_OR_DBL > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN FLT_OR_DBL const var_array_Sl_FLT_OR_DBL_Sg____setitem__(var_array< FLT_OR_DBL > const *self,int i,FLT_OR_DBL const d){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i] = d;
  }
SWIGINTERN var_array< FLT_OR_DBL > *var_array_Sl_FLT_OR_DBL_Sg____getitem____SWIG_1(var_array< FLT_OR_DBL > *self,SWIGPY_SLICEOBJECT *ob){
    size_t        n, real_i, max_i;
    unsigned int  type;
    Py_ssize_t    start, stop, step, slice_l, l;
    var_array<FLT_OR_DBL>  *a;

    if (PySlice_Check(ob)) {
      a = NULL;
      max_i = self->length;

      if (self->type & VAR_ARRAY_ONE_BASED)
        max_i += 1;

      if (self->type & VAR_ARRAY_TRI)
        max_i = var_array_data_size_tri(max_i - 1);
      else if (self->type & VAR_ARRAY_SQR)
        max_i = var_array_data_size_sqr(max_i);

      l = max_i;


      if (PySlice_GetIndicesEx(ob, l, &start, &stop, &step, &slice_l) == 0) {
        real_i  = 0;
        type    = self->type;
        n       = slice_l;

        if ((type & VAR_ARRAY_LINEAR) &&
            (type & VAR_ARRAY_ONE_BASED) &&
            (start != 0))
          type &= ~VAR_ARRAY_ONE_BASED;

        if (n > 0) {
          a = (var_array<FLT_OR_DBL> *)vrna_alloc(sizeof(var_array<FLT_OR_DBL>));
          a->data   = (FLT_OR_DBL *)vrna_alloc(sizeof(FLT_OR_DBL) * n);
          /* copy slice data */
          for (Py_ssize_t i = start; i < stop; i += step, real_i++)
            a->data[real_i] = self->data[i];

          if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED)) {
            n -= 1;
            a->data[0] = n;
          }

          a->length = n;
          a->type   = type | VAR_ARRAY_OWNED;
        }
      } else {
        return NULL;
      }

    } else {
      PyErr_SetString(PyExc_TypeError, "Expected integer or slice object");
      return 0;
    }

    return a;
  }
SWIGINTERN var_array< vrna_move_t > *new_var_array_Sl_vrna_move_t_Sg_(std::vector< vrna_move_t,std::allocator< vrna_move_t > > d,unsigned int type){
    var_array<vrna_move_t> *a = NULL;
    size_t        n = d.size();

    if (n > 0) {
      a = (var_array<vrna_move_t> *)vrna_alloc(sizeof(var_array<vrna_move_t>));
      a->data   = (vrna_move_t *)vrna_alloc(sizeof(vrna_move_t) * n);
      memcpy(a->data, &(d[0]), sizeof(vrna_move_t) * n);

      if (type & VAR_ARRAY_TRI)
        n = var_array_tri_size(n);
      else if (type & VAR_ARRAY_SQR)
        n = var_array_sqr_size(n);
      else if ((type & VAR_ARRAY_LINEAR) &&
               (type & VAR_ARRAY_ONE_BASED))
        n -= 1;

      a->length = n;
      a->type   = type | VAR_ARRAY_OWNED;
    }

    return a;
  }
SWIGINTERN void delete_var_array_Sl_vrna_move_t_Sg_(var_array< vrna_move_t > *self){
    if (self->type & VAR_ARRAY_OWNED)
      free(self->data);
    free(self);
  }
SWIGINTERN std::string var_array_Sl_vrna_move_t_Sg__type(var_array< vrna_move_t > *self){
    std::ostringstream out;

    if (self->type & VAR_ARRAY_LINEAR)
      out << "RNA.VAR_ARRAY_LINEAR";
    else  if (self->type & VAR_ARRAY_TRI)
      out << "RNA.VAR_ARRAY_TRI";
    else  if (self->type & VAR_ARRAY_SQR)
      out << "RNA.VAR_ARRAY_SQR";

    if (self->type & VAR_ARRAY_ONE_BASED)
      out << " | RNA.VAR_ARRAY_ONE_BASED";

    return std::string(out.str());
  }
SWIGINTERN size_t var_array_Sl_vrna_move_t_Sg__size(var_array< vrna_move_t > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN size_t var_array_Sl_vrna_move_t_Sg____len__(var_array< vrna_move_t > const *self){
    size_t n = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      n += 1;

    if (self->type & VAR_ARRAY_TRI)
      n = var_array_data_size_tri(n - 1);
    else if (self->type & VAR_ARRAY_SQR)
      n = var_array_data_size_sqr(n);

    return n;
  }
SWIGINTERN vrna_move_t const var_array_Sl_vrna_move_t_Sg__get(var_array< vrna_move_t > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && (-i >= max_i)) ||
        ((i >= 0) && (i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN vrna_move_t const var_array_Sl_vrna_move_t_Sg____getitem____SWIG_0(var_array< vrna_move_t > const *self,int i){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i];
  }
SWIGINTERN vrna_move_t const var_array_Sl_vrna_move_t_Sg____setitem__(var_array< vrna_move_t > const *self,int i,vrna_move_t const d){
    size_t max_i = self->length;

    if (self->type & VAR_ARRAY_ONE_BASED)
      max_i += 1;

    if (self->type & VAR_ARRAY_TRI)
      max_i = var_array_data_size_tri(max_i - 1);
    else if (self->type & VAR_ARRAY_SQR)
      max_i = var_array_data_size_sqr(max_i);

    /* also handle negative indices here */
    if (((i < 0) && ((size_t)-i >= max_i)) ||
        ((i >= 0) && ((size_t)i >= max_i)))
      throw std::out_of_range("out of bounds access");

    if (i < 0)
      i = max_i + i;

    return self->data[i] = d;
  }
SWIGINTERN var_array< vrna_move_t > *var_array_Sl_vrna_move_t_Sg____getitem____SWIG_1(var_array< vrna_move_t > *self,SWIGPY_SLICEOBJECT *ob){
    size_t        n, real_i, max_i;
    unsigned int  type;
    Py_ssize_t    start, stop, step, slice_l, l;
    var_array<vrna_move_t>  *a;

    if (PySlice_Check(ob)) {
      a = NULL;
      max_i = self->length;

      if (self->type & VAR_ARRAY_TRI)
        max_i = var_array_data_size_tri(max_i - 1);
      else if (self->type & VAR_ARRAY_SQR)
        max_i = var_array_data_size_sqr(max_i);

      l = max_i;


      if (PySlice_GetIndicesEx(ob, l, &start, &stop, &step, &slice_l) == 0) {
        real_i  = 0;
        type    = self->type;
        n       = slice_l;

        if (n > 0) {
          a = (var_array<vrna_move_t> *)vrna_alloc(sizeof(var_array<vrna_move_t>));
          a->data   = (vrna_move_t *)vrna_alloc(sizeof(vrna_move_t) * n);
          /* copy slice data */
          for (Py_ssize_t i = start; i < stop; i += step, real_i++)
            a->data[real_i] = self->data[i];

          a->length = n;
          a->type   = type | VAR_ARRAY_OWNED;
        }
      } else {
        return NULL;
      }

    } else {
      PyErr_SetString(PyExc_TypeError, "Expected integer or slice object");
      return 0;
    }

    return a;
  }

#include <sstream>


SWIGINTERN size_t
SWIG_strnlen(const char* s, size_t maxlen)
{
  const char *p;
  for (p = s; maxlen-- && *p; p++)
    ;
  return p - s;
}

SWIGINTERN vrna_param_t *new_vrna_param_t(vrna_md_t *model_details=NULL){
    return vrna_params(model_details);
  }
SWIGINTERN void delete_vrna_param_t(vrna_param_t *self){
    free(self);  
  }
SWIGINTERN std::string vrna_param_t___str__(vrna_param_t *self){
    std::ostringstream out;
    out << "{ model_details: RNA.md()";
    out << ", id: " << self->id;
    out << ", param_file: \"" << self->param_file << "\"";
    out << ", temperature: " << self->temperature;
    out << ", TerminalAU: " << self->TerminalAU;
    out << ", DuplexInit: " << self->DuplexInit;

    out << ", MLclosing: " << self->MLclosing;
    out << ", MLbase: " << self->MLbase;
    out << ", MLintern: [" << self->MLintern[0];
    for (size_t i = 1; i < NBPAIRS + 1; i++)
      out << ", " << self->MLintern[i];
    out << "]";

    out << ", hairpin: [" << self->hairpin[0];
    for (size_t i = 1; i < 31; i++)
      out << ", " << self->hairpin[i];
    out << "]";

    out << ", bulge: [" << self->bulge[0];
    for (size_t i = 1; i < MAXLOOP + 1; i++)
      out << ", " << self->bulge[i];
    out << "]";

    out << ", internal_loop: [" << self->internal_loop[0];
    for (size_t i = 1; i < 31; i++)
      out << ", " << self->internal_loop[i];
    out << "]";

    out << ", stack: [[" << self->stack[0][0];
    for (size_t a = 1; a < NBPAIRS + 1; a++)
      out << ", " << self->stack[0][a];
    out << "]";
    for (size_t a = 1; a < NBPAIRS + 1; a++) {
      out << ", [" << self->stack[a][0];
      for (size_t b = 1; b < NBPAIRS + 1; b++)
        out << ", " << self->stack[a][b];
      out << "]";
    }
    out << "]";

    out << ", dangle5: [[" << self->dangle5[0][0];
    for (size_t a = 1; a < 5; a++)
      out << ", " << self->dangle5[0][a];
    out << "]";
    for (size_t a = 1; a < NBPAIRS + 1; a++) {
      out << ", [" << self->dangle5[a][0];
      for (size_t b = 1; b < 5; b++)
        out << ", " << self->dangle5[a][b];
      out << "]";
    }
    out << "]";

    out << ", dangle3: [[" << self->dangle3[0][0];
    for (size_t a = 1; a < 5; a++)
      out << ", " << self->dangle3[0][a];
    out << "]";
    for (size_t a = 1; a < NBPAIRS + 1; a++) {
      out << ", [" << self->dangle3[a][0];
      for (size_t b = 1; b < 5; b++)
        out << ", " << self->dangle3[a][b];
      out << "]";
    }
    out << "]";

    out << ", ninio: [" << self->ninio[0];
    for (size_t i = 1; i < 5; i++)
      out << ", " << self->ninio[i];
    out << "]";

    out << ", SaltStack: " << self->SaltStack;
    out << ", SaltLoop: [" << self->SaltLoop[0];
    for (size_t i = 1; i < MAXLOOP + 1; i++)
      out << ", " << self->SaltLoop[i];
    out << "]";
    out << ", SaltLoopDbl: [" << self->SaltLoopDbl[0];
    for (size_t i = 1; i < MAXLOOP + 1; i++)
      out << ", " << self->SaltLoopDbl[i];
    out << "]";
    out << ", SaltMLbase: " << self->SaltMLbase;
    out << ", SaltMLintern: " << self->SaltMLintern;
    out << ", SaltMLclosing: " << self->SaltMLclosing;
    out << ", SaltDPXInit: " << self->SaltDPXInit;

    out << " }";

    return std::string(out.str());
  }
SWIGINTERN vrna_exp_param_t *new_vrna_exp_param_t(vrna_md_t *model_details=NULL){
    vrna_exp_param_t *P = vrna_exp_params(model_details);
    return P;
  }
SWIGINTERN void delete_vrna_exp_param_t(vrna_exp_param_t *self){
    free(self);  
  }
SWIGINTERN std::string vrna_exp_param_t___str__(vrna_exp_param_t *self){
    std::ostringstream out;
    out << "{ model_details: RNA.md()";
    out << ", id: " << self->id;
    out << ", temperature: " << self->temperature;
    out << ", kT: " << self->kT;
    out << ", alpha: " << self->alpha;
    out << ", pf_scale: " << self->alpha;
    out << " }";

    return std::string(out.str());
  }

  int
  my_params_load(std::string  filename = "",
                 unsigned int options = VRNA_PARAMETER_FORMAT_DEFAULT)
  {
    if (!filename.compare(""))
      return vrna_params_load_defaults();

    return vrna_params_load(filename.c_str(), options);
  }

  int
  my_params_save(std::string filename,
                 unsigned int options = VRNA_PARAMETER_FORMAT_DEFAULT)
  {
    return vrna_params_save(filename.c_str(), options);
  }

  int
  my_params_load_from_string(std::string parameters,
                             std::string name = "",
                             unsigned int options = VRNA_PARAMETER_FORMAT_DEFAULT)
  {
    return vrna_params_load_from_string(parameters.c_str(),
                                        name.c_str(),
                                        options);
  }


#include <sstream>

SWIGINTERN vrna_md_t *new_vrna_md_t(double temperature=vrna_md_defaults_temperature_get(),double betaScale=vrna_md_defaults_betaScale_get(),int pf_smooth=vrna_md_defaults_pf_smooth_get(),int dangles=vrna_md_defaults_dangles_get(),int special_hp=vrna_md_defaults_special_hp_get(),int noLP=vrna_md_defaults_noLP_get(),int noGU=vrna_md_defaults_noGU_get(),int noGUclosure=vrna_md_defaults_noGUclosure_get(),int logML=vrna_md_defaults_logML_get(),int circ=vrna_md_defaults_circ_get(),int circ_penalty=vrna_md_defaults_circ_penalty_get(),int gquad=vrna_md_defaults_gquad_get(),int uniq_ML=vrna_md_defaults_uniq_ML_get(),int energy_set=vrna_md_defaults_energy_set_get(),int backtrack=vrna_md_defaults_backtrack_get(),char backtrack_type=vrna_md_defaults_backtrack_type_get(),int compute_bpp=vrna_md_defaults_compute_bpp_get(),int max_bp_span=vrna_md_defaults_max_bp_span_get(),int min_loop_size=vrna_md_defaults_min_loop_size_get(),int window_size=vrna_md_defaults_window_size_get(),int oldAliEn=vrna_md_defaults_oldAliEn_get(),int ribo=vrna_md_defaults_ribo_get(),double cv_fact=vrna_md_defaults_cv_fact_get(),double nc_fact=vrna_md_defaults_nc_fact_get(),double sfact=vrna_md_defaults_sfact_get(),double salt=vrna_md_defaults_salt_get(),int saltMLLower=vrna_md_defaults_saltMLLower_get(),int saltMLUpper=vrna_md_defaults_saltMLUpper_get(),int saltDPXInit=vrna_md_defaults_saltDPXInit_get(),float saltDPXInitFact=vrna_md_defaults_saltDPXInitFact_get(),float helical_rise=vrna_md_defaults_helical_rise_get(),float backbone_length=vrna_md_defaults_backbone_length_get()){
    vrna_md_t *md       = (vrna_md_t *)vrna_alloc(sizeof(vrna_md_t));
    md->temperature     = temperature;
    md->betaScale       = betaScale;
    md->pf_smooth       = pf_smooth;
    md->dangles         = dangles;
    md->special_hp      = special_hp;
    md->noLP            = noLP;
    md->noGU            = noGU;
    md->noGUclosure     = noGUclosure;
    md->logML           = logML;
    md->circ            = circ;
    md->circ_penalty    = circ_penalty;
    md->gquad           = gquad;
    md->uniq_ML         = uniq_ML;
    md->energy_set      = energy_set;
    md->backtrack       = backtrack;
    md->backtrack_type  = backtrack_type;
    md->compute_bpp     = compute_bpp;
    md->max_bp_span     = max_bp_span;
    md->min_loop_size   = min_loop_size;
    md->window_size     = window_size;
    md->oldAliEn        = oldAliEn;
    md->ribo            = ribo;
    md->cv_fact         = cv_fact;
    md->nc_fact         = nc_fact;
    md->sfact           = sfact;
    md->salt            = salt;
    md->saltMLLower     = saltMLLower;
    md->saltMLUpper     = saltMLUpper;
    md->saltDPXInit     = saltDPXInit;
    md->saltDPXInitFact = saltDPXInitFact;
    md->helical_rise    = helical_rise;
    md->backbone_length = backbone_length;

    vrna_md_update(md);

    return md;
  }
SWIGINTERN void delete_vrna_md_t(vrna_md_t *self){
    free(self);
  }
SWIGINTERN void vrna_md_t_reset(vrna_md_t *self){
    vrna_md_set_default(self);
  }
SWIGINTERN void vrna_md_t_set_from_globals(vrna_md_t *self){
    set_model_details(self);
  }
SWIGINTERN char *vrna_md_t_option_string(vrna_md_t *self){
    return vrna_md_option_string(self);
  }
SWIGINTERN std::string vrna_md_t___str__(vrna_md_t *self){
    std::ostringstream out;
    out << "{ temperature: " << self->temperature ;
    out << ", dangles: " << self->dangles;
    out << ", betaScale: " << self->betaScale ;
    out << ", pf_smooth: " << self->pf_smooth ;
    out << ", special_hp: " << self->special_hp ;
    out << ", noLP: " << self->noLP ;
    out << ", noGU: " << self->noGU ;
    out << ", noGUclosure: " << self->noGUclosure ;
    out << ", logML: " << self->logML ;
    out << ", circ: " << self->circ ;
    out << ", circ_penalty: " << self->circ_penalty;
    out << ", gquad: " << self->gquad ;
    out << ", uniq_ML: " << self->uniq_ML ;
    out << ", energy_set: " << self->energy_set  ;
    out << ", backtrack: " << self->backtrack ;
    out << ", backtrack_type: " << self->backtrack_type ;
    out << ", compute_bpp: " << self->compute_bpp ;
    out << ", max_bp_span: " << self->max_bp_span ;
    out << ", min_loop_size: " << self->min_loop_size;
    out << ", window_size: " << self->window_size ;
    out << ", oldAliEn: " << self->oldAliEn;
    out << ", ribo: " << self->ribo;
    out << ", cv_fact: " << self->cv_fact ;
    out << ", nc_fact: " << self->nc_fact ;
    out << ", sfact: " << self->sfact ;
    out << ", salt: " << self->salt ;
    out << ", saltMLLower: " << self->saltMLLower ;
    out << ", saltMLUpper: " << self->saltMLUpper ;
    out << ", saltDPXInit: " << self->saltDPXInit ;
    out << ", saltDPXInitFact: " << self->saltDPXInitFact ;
    out << ", helical_rise: " << self->helical_rise ;
    out << ", backbone_length: " << self->backbone_length ;
    out << " }";

    return std::string(out.str());
  }

  int
  my_hamming(const char *s1,
             const char *s2)
  {
    return vrna_hamming_distance(s1, s2);
  }


  int
  my_hamming_bound(const char *s1,
                   const char *s2,
                   int n)
  {
    return vrna_hamming_distance_bound(s1, s2, n);
  }



#include <cstring>

short *
encode_seq(char *sequence)
{
  unsigned int i,l;
  short *S;
  l = strlen(sequence);
  S = (short *) vrna_alloc(sizeof(short)*(l+2));
  S[0] = (short) l;

  /* make numerical encoding of sequence */
  for (i=1; i<=l; i++)
    S[i]= (short) encode_char(toupper(sequence[i-1]));

  /* for circular folding add first base at position n+1 */
  S[l+1] = S[1];

  return S;
}


  unsigned int
  my_strtrim(char          *seq_mutable,
             const char    *delimiters  = NULL,
             unsigned int  keep         = 0,
             unsigned int  options      = VRNA_TRIM_DEFAULT)
  {
    return  vrna_strtrim(seq_mutable,
                         delimiters,
                         keep,
                         options);
  }


  std::vector<double>
  my_str_to_dbl_array(const std::string &s,
                      const std::string &delimiter = " ",
                      unsigned int      options = 0)
  {
    std::vector<double> vs;
    vrna_array(double) c_vs;

    c_vs = vrna_str_to_dbl_array(s.c_str(), delimiter.c_str(), options);

    if (c_vs) {
      for (size_t i = 0; i < vrna_array_size(c_vs); i++)
        printf("v[%ld] = %f", i, c_vs[i]);

      vs = std::vector<double>(c_vs, c_vs + vrna_array_size(c_vs));
    }

    vrna_array_free(c_vs);

    return vs;
  }



#include <sstream>

SWIGINTERN vrna_ep_t *new_vrna_ep_t(unsigned int i,unsigned int j,float p=1.,int type=VRNA_PLIST_TYPE_BASEPAIR){
      vrna_ep_t *pair;

      pair        = (vrna_ep_t *)vrna_alloc(sizeof(vrna_ep_t));
      pair->i     = (int)i;
      pair->j     = (int)j;
      pair->p     = p;
      pair->type  = type;

      return pair;
    }
SWIGINTERN std::string vrna_ep_t___str__(vrna_ep_t *self){
      std::ostringstream out;
      out << "{ i: " << self->i;
      out << ", j: " << self->j;
      out << ", p: " << self->p;
      out << ", t: " << self->type;
      out << " }";

      return std::string(out.str());
    }

#include <vector>
  char *
  my_pack_structure(const char *s)
  {
    return vrna_db_pack(s);
  }

  char *
  my_unpack_structure(const char *packed)
  {
    return vrna_db_unpack(packed);
  }

  char *
  my_db_from_ptable(std::vector<int> pt)
  {
    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);
    return vrna_db_from_ptable((short*)&vc[0]);
  }

  char *
  my_db_from_ptable(var_array<short> const &pt)
  {
    return vrna_db_from_ptable(pt.data);
  }

  void
  db_flatten(char         *structure,
             unsigned int options = VRNA_BRACKETS_DEFAULT)
  {
    vrna_db_flatten(structure, options);
  }

  void
  db_flatten(char         *structure,
             std::string  target,
             unsigned int options = VRNA_BRACKETS_DEFAULT)
  {
    if (target.size() == 2)
      vrna_db_flatten_to(structure, target.c_str(), options);
    else
      vrna_log_warning("db_flatten(): target pair must be string of exactly 2 characters!");
  }

  std::string
  db_from_WUSS(std::string wuss)
  {
    char *c_str = vrna_db_from_WUSS(wuss.c_str());
    std::string db = c_str;
    free(c_str);
    return db;
  }

  std::string
  abstract_shapes(std::string   structure,
                  unsigned int  level = 5)
  {
    if (structure.size() == 0)
      return structure;

    char *c_str = vrna_abstract_shapes(structure.c_str(), level);
    std::string SHAPE = c_str;
    free(c_str);
    return SHAPE;
  }

  std::string
  abstract_shapes(std::vector<int> pt,
                  unsigned int     level = 5)
  {
    if (pt.size() == 0)
      return "";

    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);

    char *c_str = vrna_abstract_shapes_pt((short*)&vc[0], level);

    std::string SHAPE = c_str;
    free(c_str);
    return SHAPE;
  }

  std::string
  abstract_shapes(var_array<short> const &pt,
                  unsigned int     level = 5)
  {
    char *c_str = vrna_abstract_shapes_pt(pt.data, level);

    std::string SHAPE = c_str;
    free(c_str);
    return SHAPE;
  }


#include <vector>

#ifdef SWIGPYTHON
  var_array<short int> *
  my_ptable(std::string   str,
            unsigned int  options = VRNA_BRACKETS_RND)
  {
    short int       *pt;
    int             i;
    var_array<short int>  *v_pt;

    pt = vrna_ptable_from_string(str.c_str(), options);
    v_pt = var_array_new(str.size(),
                         pt,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED | VAR_ARRAY_OWNED);

    return v_pt;
  }

#else
  std::vector<int>
  my_ptable(std::string   str,
            unsigned int  options = VRNA_BRACKETS_RND)
  {
    short int         *pt;
    int               i;
    std::vector<int>  v_pt;

    pt = vrna_ptable_from_string(str.c_str(), options);

    for(i = 0; i <= pt[0]; i++)
      v_pt.push_back(pt[i]);

    free(pt);
    return v_pt;
  }
#endif

  std::vector<int>
  my_ptable_pk(std::string str)
  {
    short int* pt_pk = vrna_pt_pk_get(str.c_str());
    std::vector<int> v_pt;
    int i;

    for(i=0; i <= pt_pk[0]; i++){
      v_pt.push_back(pt_pk[i]);
    }
    free(pt_pk);
    return v_pt; 
  }

  std::vector<int>
  my_pt_pk_remove(std::vector<int>  pt,
                  unsigned int      options = 0)
  {
    short               *ptable;
    int                 i;
    std::vector<short>  vs;
    std::vector<int>    v_pt;

    /* sanity check and fix */
    if (pt[0] != pt.size() - 1)
      pt[0] = pt.size() - 1;

    transform(pt.begin(), pt.end(), back_inserter(vs), convert_vecint2vecshort);

    ptable = vrna_pt_pk_remove((const short*)&vs[0], options);

    for (i = 0; i <= ptable[0]; i++)
      v_pt.push_back(ptable[i]);

    free(ptable);

    return v_pt;
  }

  var_array<short> *
  my_pt_pk_remove(var_array<short> const &pt,
                  unsigned int      options = 0)
  {
    short *ptable = vrna_pt_pk_remove(pt.data, options);

    return var_array_new(ptable[0],
                         ptable,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED | VAR_ARRAY_OWNED);
  }



#include <vector>
  std::vector<vrna_ep_t>
  my_plist(std::string  structure,
           float        pr = 0.95*0.95)
  {
    std::vector<vrna_ep_t > ep_v;
    vrna_ep_t               *ptr, *plist;

    plist = vrna_plist(structure.c_str(), pr);

    if (plist) {
      for (ptr = plist; ptr->i && ptr->j; ptr++) {
        vrna_ep_t pl;
        pl.i = ptr->i;
        pl.j = ptr->j;
        pl.p = ptr->p;
        pl.type = ptr->type;
        ep_v.push_back(pl);
      }

      free(plist);
    }

    return ep_v;
  }

  std::string
  db_from_plist(std::vector<vrna_ep_t> pairs,
                unsigned int           length)
  {
    vrna_ep_t last_elem;
    last_elem.i     = last_elem.j = 0;
    last_elem.p     = 0;
    last_elem.type  = 0;

    pairs.push_back(last_elem);

    char *str = vrna_db_from_plist(&pairs[0], length);
    std::string ret(str);
    free(str);

    /* remove end-of-list marker */
    pairs.pop_back();

    return ret;
  }

  std::string
  db_pk_remove(std::string  structure,
               unsigned int options = VRNA_BRACKETS_ANY)
  {
    char *db = vrna_db_pk_remove(structure.c_str(), options);
    std::string ret(db);
    free(db);

    return ret;
  }


  std::string
  db_to_tree_string(std::string   structure,
                    unsigned int  type)
  {
    char *c_str = vrna_db_to_tree_string(structure.c_str(), type);
    std::string tree = c_str;
    free(c_str);
    return tree;
  }

  std::string
  tree_string_unweight(std::string structure)
  {
    char *c_str = vrna_tree_string_unweight(structure.c_str());
    std::string tree = c_str;
    free(c_str);
    return tree;
  }

  std::string
  tree_string_to_db(std::string structure)
  {
    char *c_str = vrna_tree_string_to_db(structure.c_str());
    std::string db = c_str;
    free(c_str);
    return db;
  }



  short *
  make_loop_index(const char *structure)
  {
    /* number each position by which loop it belongs to (positions start at 0) */
    int i,hx,l,nl;
    int length;
    short *stack;
    short *loop;
    length = strlen(structure);
    stack = (short *) vrna_alloc(sizeof(short)*(length+1));
    loop = (short *) vrna_alloc(sizeof(short)*(length+2));
    hx=l=nl=0;
    for (i=0; i<length; i++) {
      if (structure[i] == '(') {
        nl++; l=nl;
        stack[hx++]=i;
      }
      loop[i]=l;
      if (structure[i] ==')') {
        --hx;
        if (hx>0)
          l = loop[stack[hx-1]];  /* index of enclosing loop   */
        else l=0;                 /* external loop has index 0 */
        if (hx<0) {
          fprintf(stderr, "%s\n", structure);
          nrerror("unbalanced brackets in make_loop_index");
        }
      }
    }
    free(stack);
    return loop;
  }


  std::vector<int>
  my_loopidx_from_ptable(std::vector<int> pt)
  {
    int                 i, *idx;
    std::vector<short>  vc;
    std::vector<int>    v_idx;

    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);

    idx = vrna_loopidx_from_ptable((short *)&vc[0]);

    v_idx.assign(idx, idx + pt.size());

    free(idx);

    return v_idx;
  }

  var_array<int> *
  my_loopidx_from_ptable(var_array<short> const &pt)
  {
    int *idx = vrna_loopidx_from_ptable(pt.data);
    return var_array_new(pt.data[0], idx, VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED | VAR_ARRAY_OWNED);
  }

SWIGINTERN vrna_hx_t *new_vrna_hx_t(unsigned int start,unsigned int end,unsigned int length,unsigned int up5=0,unsigned int up3=0){
      vrna_hx_t *helix;

      helix         = (vrna_hx_t *)vrna_alloc(sizeof(vrna_hx_t));
      helix->start  = start;
      helix->end    = end;
      helix->length = length;
      helix->up5    = up5;
      helix->up3    = up3;

      return helix;
    }
SWIGINTERN std::string vrna_hx_t___str__(vrna_hx_t *self){
      std::ostringstream out;
      out << "{ start: " << self->start;
      out << ", end: " << self->end;
      out << ", length: " << self->length;
      out << ", up5: " << self->up5;
      out << ", up3: " << self->up3;
      out << " }";

      return std::string(out.str());
    }

#include <vector>
  std::vector<vrna_hx_t>
  my_hx_from_ptable(std::vector<int> pt)
  {
    std::vector<vrna_hx_t>  hx_v;
    std::vector<short>      v_pt;
    vrna_hx_t               *ptr, *hxlist;

    transform(pt.begin(), pt.end(), back_inserter(v_pt), convert_vecint2vecshort);

    hxlist = vrna_hx_from_ptable((short *)&v_pt[0]);

    for (ptr = hxlist; ptr->start && ptr->end; ptr++) {
      vrna_hx_t hx;
      hx.start  = ptr->start;
      hx.end    = ptr->end;
      hx.length = ptr->length;
      hx.up5    = ptr->up5;
      hx.up3    = ptr->up3;
      hx_v.push_back(hx);
    }

    free(hxlist);

    return hx_v;
  }

  std::vector<vrna_hx_t>
  my_hx_from_ptable(var_array<short> const &pt)
  {
    std::vector<vrna_hx_t>  hx_v;
    vrna_hx_t               *ptr, *hxlist;

    hxlist = vrna_hx_from_ptable(pt.data);

    for (ptr = hxlist; ptr->start && ptr->end; ptr++) {
      vrna_hx_t hx;
      hx.start  = ptr->start;
      hx.end    = ptr->end;
      hx.length = ptr->length;
      hx.up5    = ptr->up5;
      hx.up3    = ptr->up3;
      hx_v.push_back(hx);
    }

    free(hxlist);

    return hx_v;
  }

  std::vector<vrna_hx_t>
  my_hx_merge(std::vector<vrna_hx_t>  list,
              int                     maxdist = 0)
  {
    std::vector<vrna_hx_t>  hx_merged_v;
    vrna_hx_t               *ptr, *hx_merged;

    vrna_hx_t hx;
    hx.start = hx.end = hx.length = hx.up5 = hx.up3 = 0;
    list.push_back(hx);

    hx_merged = vrna_hx_merge(&(list[0]), maxdist);

    list.pop_back();

    for (ptr = hx_merged; ptr->start && ptr->end; ptr++) {
      vrna_hx_t hx;
      hx.start  = ptr->start;
      hx.end    = ptr->end;
      hx.length = ptr->length;
      hx.up5    = ptr->up5;
      hx.up3    = ptr->up3;
      hx_merged_v.push_back(hx);
    }

    free(hx_merged);

    return hx_merged_v;
  }


  int
  my_bp_distance(std::string str1,
                 std::string str2,
                 unsigned int options = VRNA_BRACKETS_RND)
  {
    int dist = 0;
    short int *pt1, *pt2;

    pt1 = vrna_ptable_from_string(str1.c_str(), options);
    pt2 = vrna_ptable_from_string(str2.c_str(), options);

    dist = vrna_bp_distance_pt(pt1, pt2);

    free(pt1);
    free(pt2);

    return dist;
  }

  int
  my_bp_distance(std::vector<int> pt1,
                 std::vector<int> pt2)
  {
    std::vector<short> pt1_v_short;
    std::vector<short> pt2_v_short;

    transform(pt1.begin(), pt1.end(), back_inserter(pt1_v_short), convert_vecint2vecshort);
    transform(pt2.begin(), pt2.end(), back_inserter(pt2_v_short), convert_vecint2vecshort);

    return vrna_bp_distance_pt((short*)&pt1_v_short[0], (short*)&pt2_v_short[0]);
  }

  int
  my_bp_distance(var_array<short> const &pt1,
                 var_array<short> const &pt2)
  {
    return vrna_bp_distance_pt(pt1.data, pt2.data);
  }

  double
  my_dist_mountain( std::string   str1,
                    std::string   str2,
                    unsigned int  p = 1)
  {
    return vrna_dist_mountain(str1.c_str(), str2.c_str(), p);
  }

SWIGINTERN vrna_score_t *new_vrna_score_t(double TP=0.,double TN=0.,double FP=0.,double FN=0.){
      vrna_score_t *score;

      score         = (vrna_score_t *)vrna_alloc(sizeof(vrna_score_t));
      *score = vrna_score_from_confusion_matrix(TP, TN, FP, FN);

      return score;
    }
SWIGINTERN std::string vrna_score_t___str__(vrna_score_t *self){
      std::ostringstream out;
      out << "{ TP: " << self->TP;
      out << ", TN: " << self->TN;
      out << ", FP: " << self->FP;
      out << ", FN: " << self->FN;
      out << ", TPR: " << self->TPR;
      out << ", PPV: " << self->PPV;
      out << ", FPR: " << self->FPR;
      out << ", FOR: " << self->FOR;
      out << ", TNR: " << self->TNR;
      out << ", FDR: " << self->FDR;
      out << ", FNR: " << self->FNR;
      out << ", NPV: " << self->NPV;
      out << ", F1: " << self->F1;
      out << ", MCC: " << self->MCC;
      out << " }";

      return std::string(out.str());
    }

  vrna_score_t
  my_compare_structure(std::string str1,
                       std::string str2,
                       int fuzzy = 0,
                       unsigned int options = VRNA_BRACKETS_RND)
  {
    return vrna_compare_structure(str1.c_str(), str2.c_str(), fuzzy, options);
  }

  vrna_score_t
  my_compare_structure(std::vector<int> pt1,
                       std::vector<int> pt2,
                       int fuzzy = 0)
  {
    std::vector<short> pt1_v_short;
    std::vector<short> pt2_v_short;

    transform(pt1.begin(), pt1.end(), back_inserter(pt1_v_short), convert_vecint2vecshort);
    transform(pt2.begin(), pt2.end(), back_inserter(pt2_v_short), convert_vecint2vecshort);

    return vrna_compare_structure_pt((short*)&pt1_v_short[0], (short*)&pt2_v_short[0], fuzzy);
  }

  vrna_score_t
  my_compare_structure(var_array<short> const &pt1,
                       var_array<short> const &pt2,
                       int fuzzy = 0)
  {
    return vrna_compare_structure_pt(pt1.data, pt2.data, fuzzy);
  }


  unsigned int
  my_gq_parse(std::string               structure,
              unsigned int              *L,
              std::vector<unsigned int> *l)
  {
    unsigned int c_L, c_l[3], pos = 0;

    if (structure.size() > 0) {
      *L = 0;
      l->clear();

      pos = vrna_gq_parse(structure.c_str(), &c_L, &(c_l[0]));

      if (pos) {
        *L = c_L;
        l->push_back(c_l[0]);
        l->push_back(c_l[1]);
        l->push_back(c_l[2]);
      }

      return pos;
    }
    
    return pos;
  }



#include <vector>

  std::string
  my_aln_consensus_sequence(std::vector<std::string>  alignment,
                            vrna_md_t                 *md_p = NULL)
  {
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  v;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(v), convert_vecstring2veccharcp);
    v.push_back(NULL); /* mark end of sequences */

    char *c = vrna_aln_consensus_sequence((const char **)&v[0], md_p);
    std::string cons(c);
    free(c);
    return cons;
  }

  std::string
  my_aln_consensus_mis(std::vector<std::string> alignment,
                       vrna_md_t                *md_p = NULL)
  {
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  v;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(v), convert_vecstring2veccharcp);
    v.push_back(NULL); /* mark end of sequences */

    char *c = vrna_aln_consensus_mis((const char **)&v[0], md_p);
    std::string mis(c);
    free(c);
    return mis;
  }

  std::string
  my_aln_consensus_sequence2(std::vector<std::string>  alignment,
                            vrna_md_t                 *md_p = NULL)
  {
    return my_aln_consensus_sequence(alignment, md_p);
  }

  std::string
  my_aln_consensus_mis2(std::vector<std::string> alignment,
                       vrna_md_t                *md_p = NULL)
  {
    return my_aln_consensus_mis(alignment, md_p);
  }


#include <vector>

  int
  my_aln_mpi(std::vector<std::string> alignment)
  {
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  v;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(v), convert_vecstring2veccharcp);
    v.push_back(NULL); /* mark end of sequences */

    int mpi = vrna_aln_mpi((const char **)&v[0]);

    return mpi;
  }



#include <vector>

  std::vector<std::vector<int> >
  my_aln_pscore(std::vector<std::string>  alignment,
                vrna_md_t                 *md = NULL)
  {

    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  v;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(v), convert_vecstring2veccharcp);
    v.push_back(NULL); /* mark end of sequences */

    std::vector<std::vector<int> > pscore;
    int *ps = vrna_aln_pscore((const char **)&v[0], md);

    int n     = alignment[0].length();
    int *idx  = vrna_idx_col_wise(n);

    std::vector<int> z_row(n+1, 0);
    pscore.push_back(z_row);

    for(int i = 1; i < n; i++){
      std::vector<int> score_i;
      score_i.push_back(0);
      for(int j = 1; j <= i; j++)
        score_i.push_back(ps[idx[i] + j]);
      for(int j = i + 1; j <= n; j++)
        score_i.push_back(ps[idx[j] + i]);
      pscore.push_back(score_i);
    }

    free(ps);
    free(idx);

    return pscore;
  }



#include <vector>

  std::vector<double>
  my_aln_conservation_struct(std::vector<std::string> alignment,
                             std::string              structure,
                             vrna_md_t                *md = NULL)
  {
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  v;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(v), convert_vecstring2veccharcp);
    v.push_back(NULL); /* mark end of sequences */

    std::vector<double> conservation;

    float *c = vrna_aln_conservation_struct((const char **)&v[0], structure.c_str(), md);

    if (c) {
      for (unsigned int i = 0; i <= alignment[0].size(); i++)
        conservation.push_back((double)c[i]);

      free(c);
    }

    return conservation;
  }
  std::vector<double>
  my_aln_conservation_col(std::vector<std::string> alignment,
                          vrna_md_t                *md = NULL,
                          unsigned int             options = VRNA_MEASURE_SHANNON_ENTROPY)
  {
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  v;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(v), convert_vecstring2veccharcp);
    v.push_back(NULL); /* mark end of sequences */

    std::vector<double> conservation;

    float *c = vrna_aln_conservation_col((const char **)&v[0], md, options);

    if (c) {
      for (unsigned int i = 0; i <= alignment[0].size(); i++)
        conservation.push_back((double)c[i]);

      free(c);
    }

    return conservation;
  }


  char *
  my_move_standard(int            *OUTPUT,
                   char           *seq,
                   char           *struc,
                   enum MOVE_TYPE type,
                   int            verbosity_level,
                   int            shifts,
                   int            noLP)
  {
    char *structure =  (char *)calloc(strlen(struc)+1,sizeof(char));
    strcpy(structure,struc);
    *OUTPUT = move_standard(seq,structure,type,verbosity_level,shifts,noLP);
    return structure;   
  }


  std::string
  my_filename_sanitize(std::string name)
  {
    std::string s;
    char *name_sanitized = vrna_filename_sanitize(name.c_str(), NULL);
    if (name_sanitized)
      s = (const char *)name_sanitized;
    free(name_sanitized);
    return s;
  }

  std::string
  my_filename_sanitize(std::string  name,
                       char         c)
  {
    std::string s;
    char *name_sanitized = vrna_filename_sanitize(name.c_str(), &c);
    if (name_sanitized)
      s = (const char *)name_sanitized;
    free(name_sanitized);
    return s;
  }



#include <stdexcept>

typedef struct {
  PyObject  *cb;
  PyObject  *data;
  PyObject  *delete_data;
} pycallback_log_t;

static void
py_wrap_log_callback(vrna_log_event_t  *event,
                     void              *log_data);

static void
delete_py_log(pycallback_log_t *cb)
{
  if(cb->data != Py_None){
    if(cb->delete_data != Py_None){
      /* call user-defined data destructor */
      PyObject *func, *arglist, *result, *err;
      func = cb->delete_data;
      arglist = Py_BuildValue("O", cb->data);
      result  = PyObject_CallObject(func, arglist);

      /* BEGIN recognizing errors in callback execution */
      if (result == NULL) {
        if ((err = PyErr_Occurred())) {
          /* print error message */
          PyErr_Print();
          /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
          if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
            throw std::runtime_error( "log_cb delete_data() callback must take exactly 1 argument" );
          } else {
            throw std::runtime_error( "Some error occurred while executing log_cb delete_data() callback" );
          }
        }
        PyErr_Clear();
      }
      /* END recognizing errors in callback execution */

      Py_DECREF(arglist);
      Py_XDECREF(result);
    }
  }

  Py_DECREF(cb->data);
  Py_DECREF(cb->delete_data);
}


static void
delete_pycallback_log(void * data)
{
  pycallback_log_t *cb = (pycallback_log_t *)data;
  /* first delete user data */
  delete_py_log(cb);

  /* now dispose of the callback */
  Py_DECREF(cb->cb);
  
  /* finally free pycallback */
  free(cb);
}


static unsigned int
log_cb_add_pycallback(PyObject  *PyFunc,
              PyObject          *data,
              PyObject          *data_release,
              vrna_log_levels_e level)
{
  unsigned int r;

  pycallback_log_t *cb;

  cb = (pycallback_log_t *)vrna_alloc(sizeof(pycallback_log_t));

  cb->cb          = PyFunc;    /* remember callback */
  cb->data        = data;
  cb->delete_data = data_release;

  Py_INCREF(data);
  Py_XINCREF(PyFunc);       /* Increase referenc counter */
  Py_XINCREF(data_release); /* Increase referenc counter */

  /* finaly bind to logging system */
  r = vrna_log_cb_add(&py_wrap_log_callback,
                      (void *)cb,
                      &delete_pycallback_log,
                      level);

  return r;
}


static void
py_wrap_log_callback(vrna_log_event_t  *event,
                     void              *data)
{

  PyObject *func, *arglist, *result, *err;
  pycallback_log_t *cb = (pycallback_log_t *)data;

  func = cb->cb;

  /* compose argument list */
  char      *message  = vrna_strdup_vprintf(event->format_string, event->params);
  char      *fn       = vrna_strdup_printf(event->file_name);

  arglist = Py_BuildValue("{s:s,s:i,s:i,s:s},O",
                "message", message,
                "level", event->level,
                "line_number", event->line_number,
                "file_name", fn,
                (cb->data) ? cb->data : Py_None);

  result =  PyObject_CallObject(func, arglist);

  free(message);
  free(fn);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "logging callback must take exactly 2 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing logging callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_DECREF(arglist);
  Py_XDECREF(result);

  return /*void*/;
}



  unsigned int
  log_cb_add(PyObject *callback,
             PyObject *data           = Py_None,
             PyObject *data_release   = Py_None,
             vrna_log_levels_e level  = VRNA_LOG_LEVEL_WARNING)
  {
    return log_cb_add_pycallback(callback, data, data_release, level);
  }



const char *
obj_to_mode(PyObject *obj) {
  static const char * const file_mode[] = {"w+", "w", "r"};
  PyObject *writable_fn, *readable_fn, *readable_res, *writable_res;

  if (! (readable_fn = PyObject_GetAttrString (obj, "readable"))) {
    PyErr_SetString (PyExc_TypeError, "Object has no readable function.");
    return NULL;
  }

  if (! (writable_fn = PyObject_GetAttrString (obj, "writable"))) {
    PyErr_SetString (PyExc_TypeError, "Object has no writable function.");
    return NULL;
  }

  if (! (readable_res = PyObject_CallObject(readable_fn, NULL))) {
    PyErr_SetString (PyExc_SystemError, "Error calling readable function.");
    return NULL;
  }

  if (! (writable_res = PyObject_CallObject(writable_fn, NULL))) {
    PyErr_SetString (PyExc_SystemError, "Error calling writable function.");
    return NULL;
  }

  if (PyObject_IsTrue(readable_res)) {
    if (PyObject_IsTrue(writable_res)) {
      return file_mode[0];
    } else {
      return file_mode[2];
    }
  } else if (PyObject_IsTrue(writable_res)) {
    return file_mode[1];
  }

  PyErr_SetString (PyExc_SystemError, "Object is neither readable nor writable.");

  return NULL;
}


FILE *
obj_to_file(PyObject *obj, long int *start_position) {
#if PY_VERSION_HEX >= 0x03000000
  int fd, fd2;
  long int position;
  FILE *fp = NULL;
  PyObject *ret, *os;
  if (!PyLong_Check(obj) &&                                /* is not an integer */
      PyObject_HasAttrString(obj, "fileno") &&             /* has fileno method */
      (PyObject_CallMethod(obj, "flush", NULL) != NULL) && /* flush() succeeded */
      ((fd = PyObject_AsFileDescriptor(obj)) != -1)        /* got file descriptor */
    ) {
    os = PyImport_ImportModule("os");
    if (os == NULL)
      return NULL;

    ret = PyObject_CallMethod(os, (char *)"dup", (char *)"i", fd);
    Py_DECREF(os);

    if (ret == NULL)
      return NULL;

    fd2 = (int)PyNumber_AsSsize_t(ret, NULL);
    Py_DECREF(ret);

    const char *mode = obj_to_mode(obj);

    if (mode) {
      fp = fdopen(fd2, mode); /* the FILE* must be flushed
                                 and closed after being used */
    } else {
      return NULL;
    }

    if (fp == NULL) {
      PyErr_SetString(PyExc_IOError, "Failed to get FILE * from Python file object");
      return NULL;
    }

    *start_position = ftell(fp);

    if (*start_position == -1) {
      /* fp is stream */
      return fp;
    }

    ret = PyObject_CallMethod(obj, (char *)"tell", (char *)"");
    if (ret == NULL) {
      fclose(fp);
      return NULL;
    }

    position = PyNumber_AsSsize_t(ret, PyExc_OverflowError);
    Py_DECREF(ret);

    if (PyErr_Occurred()) {
      fclose(fp);
      return NULL;
    }

    if (fseek(fp, position, SEEK_SET) == -1) {
      PyErr_SetString(PyExc_IOError, "Failed to seek FILE * to PyObject position");
      return NULL;
    }





    return fp;
  }
#endif
  return NULL;
}


int
dispose_file(FILE **fp, PyObject *pyfile, long int start_position) {
  if (*fp == NULL)
    return 0;

  int fd;
  long int position;
  PyObject *ret, *exc_type, *exc_value, *exc_tb;

  exc_type = exc_value = exc_tb = NULL;
  PyErr_Fetch(&exc_type, &exc_value, &exc_tb);

  position = ftell(*fp);








  if (!((fflush(*fp) == 0) &&
        (fclose(*fp) == 0)))
    return -1;

  *fp = NULL;

  fd = PyObject_AsFileDescriptor(pyfile);
  if (fd == -1)
    goto fail_dispose_file;

  if (lseek(fd, start_position, SEEK_SET) != -1) {
    if (position == -1) {
      PyErr_SetString(PyExc_IOError, "Failed to obtain FILE * position");
      goto fail_dispose_file;
    }

    ret = PyObject_CallMethod(pyfile, (char *)"seek", (char *)"ii", position, 0);
    if (ret == NULL)
      goto fail_dispose_file;

    Py_DECREF(ret);
  }

  PyErr_Restore(exc_type, exc_value, exc_tb);
  return 0;

fail_dispose_file:
  Py_XDECREF(exc_type);
  Py_XDECREF(exc_value);
  Py_XDECREF(exc_tb);
  
  return -1;
}


  COORDINATE *
  get_xy_coordinates(const char *structure)
  {
    int         i, ret;
    short       length  = (short) strlen(structure);
    COORDINATE  *coords = (COORDINATE *) vrna_alloc((length+1)*sizeof(COORDINATE));
    float       *X, *Y;

    ret = vrna_plot_coords(structure, &X, &Y, rna_plot_type);

    if (ret == (int)length) {
      for(i=0;i<=length;i++){
        coords[i].X = X[i];
        coords[i].Y = Y[i];
      }
    }
    free(X);
    free(Y);

    return(coords);
  }


#include <vector>
#include <string>

  std::vector<COORDINATE>
  my_simple_xy_coordinates(std::string structure)
  {
    std::vector<COORDINATE> ret;
    short *table  = vrna_ptable(structure.c_str());
    float *X      = (float *) vrna_alloc((table[0]+1)*sizeof(float));
    float *Y      = (float *) vrna_alloc((table[0]+1)*sizeof(float));
    simple_xy_coordinates(table, X, Y);

    for(int i = 0; i <= table[0]; i++){
      COORDINATE c;
      c.X = X[i];
      c.Y = Y[i];
      ret.push_back(c);
    }

    free(X);
    free(Y);
    free(table);
    return ret;
  }

  std::vector<COORDINATE>
  my_simple_circplot_coordinates(std::string structure)
  {
    std::vector<COORDINATE> ret;
    short *table  = vrna_ptable(structure.c_str());
    float *X      = (float *) vrna_alloc((table[0]+1)*sizeof(float));
    float *Y      = (float *) vrna_alloc((table[0]+1)*sizeof(float));
    simple_circplot_coordinates(table, X, Y);

    for(int i = 0; i <= table[0]; i++){
      COORDINATE c;
      c.X = X[i];
      c.Y = Y[i];
      ret.push_back(c);
    }

    free(X);
    free(Y);
    free(table);
    return ret;
  }

#ifdef VRNA_WITH_NAVIEW_LAYOUT
  std::vector<COORDINATE>
  my_naview_xy_coordinates(std::string structure)
  {
    std::vector<COORDINATE> ret;
    short *table  = vrna_ptable(structure.c_str());
    float *X      = (float *) vrna_alloc((table[0]+1)*sizeof(float));
    float *Y      = (float *) vrna_alloc((table[0]+1)*sizeof(float));
    naview_xy_coordinates(table, X, Y);

    for(int i = 0; i <= table[0]; i++){
      COORDINATE c;
      c.X = X[i];
      c.Y = Y[i];
      ret.push_back(c);
    }

    free(X);
    free(Y);
    free(table);
    return ret;
  }
#endif


SWIGINTERN vrna_plot_layout_t *new_vrna_plot_layout_t(std::string structure,unsigned int plot_type=VRNA_PLOT_TYPE_DEFAULT){
    return vrna_plot_layout(structure.c_str(),
                            plot_type);
  }
SWIGINTERN void delete_vrna_plot_layout_t(vrna_plot_layout_t *self){
    vrna_plot_layout_free(self);
  }
SWIGINTERN vrna_plot_options_puzzler_t *vrna_plot_options_puzzler_t_vrna_plot_options_puzzler_t(vrna_plot_options_puzzler_t *self){
    return vrna_plot_options_puzzler();
  }
SWIGINTERN void delete_vrna_plot_options_puzzler_t(vrna_plot_options_puzzler_t *self){
    vrna_plot_options_puzzler_free(self);
  }
SWIGINTERN COORDINATE *COORDINATE_get(COORDINATE *self,int i){
    return self+i;
  }

  int
  my_PS_rna_plot_snoop_a( std::string               sequence,
                          std::string               structure,
                          std::string               filename,
                          std::vector<int>          relative_access,
                          std::vector<std::string>  seqs)
  {
    std::vector<const char*> seqs_vec;
    std::transform(seqs.begin(), seqs.end(), std::back_inserter(seqs_vec), convert_vecstring2veccharcp);
    seqs_vec.push_back(NULL); /* mark end of sequences */

    return PS_rna_plot_snoop_a( sequence.c_str(),
                                structure.c_str(),
                                filename.c_str(),
                                &relative_access[0],
                                (const char **)&seqs_vec[0]);
  }

  int
  file_PS_rnaplot(std::string sequence,
                  std::string structure,
                  std::string filename,
                  vrna_md_t   *md_p = NULL)
  {
    return vrna_file_PS_rnaplot(sequence.c_str(), structure.c_str(), filename.c_str(), md_p);
  }

  int
  file_PS_rnaplot_a(std::string sequence,
                    std::string structure,
                    std::string filename,
                    std::string pre,
                    std::string post,
                    vrna_md_t   *md_p = NULL)
  {
    return vrna_file_PS_rnaplot_a(sequence.c_str(), structure.c_str(), filename.c_str(), pre.c_str(), post.c_str(), md_p);
  }


SWIGINTERN vrna_plot_data_t *new_vrna_plot_data_t(std::string pre="",std::string post="",vrna_md_t *md=NULL,unsigned int options=0){
    vrna_plot_data_t  *d = NULL;

    if ((pre.size() > 0) ||
        (post.size() > 0) ||
        (md)) {
      d           = (vrna_plot_data_t *)vrna_alloc(sizeof(vrna_plot_data_t));
      d->pre      = (pre.size() > 0) ? strdup(pre.c_str()) : NULL;
      d->post     = (post.size() > 0) ? strdup(post.c_str()) : NULL;
      d->md       = md;
      d->options  = options;
    }

    return d;
  }
SWIGINTERN void delete_vrna_plot_data_t(vrna_plot_data_t *self){
    free(self->pre);
    free(self->post);
    free(self);
  }

  int
  my_plot_structure(std::string         filename,
                    std::string         sequence,
                    std::string         structure,
                    unsigned int        file_format = VRNA_FILE_FORMAT_PLOT_DEFAULT,
                    vrna_plot_layout_t  *layout     = NULL,
                    vrna_plot_data_t    *data       = NULL)
  {
    return vrna_plot_structure(filename.c_str(),
                               sequence.c_str(),
                               structure.c_str(),
                               file_format,
                               layout,
                               data);
  }


  int
  my_plot_structure_eps(std::string         filename,
                        std::string         sequence,
                        std::string         structure,
                        vrna_plot_layout_t  *layout = NULL,
                        vrna_plot_data_t    *data   = NULL)
  {
    return vrna_plot_structure_eps(filename.c_str(),
                                   sequence.c_str(),
                                   structure.c_str(),
                                   layout,
                                   data);
  }


  int
  my_plot_structure_svg(std::string         filename,
                        std::string         sequence,
                        std::string         structure,
                        vrna_plot_layout_t  *layout = NULL,
                        vrna_plot_data_t    *data   = NULL)
  {
    return vrna_plot_structure_svg(filename.c_str(),
                                 sequence.c_str(),
                                 structure.c_str(),
                                 layout,
                                 data);
  }


  int
  my_plot_structure_gml(std::string         filename,
                        std::string         sequence,
                        std::string         structure,
                        vrna_plot_layout_t  *layout = NULL,
                        vrna_plot_data_t    *data   = NULL,
                        char                option  = 'x')
  {
    return vrna_plot_structure_gml(filename.c_str(),
                                   sequence.c_str(),
                                   structure.c_str(),
                                   layout,
                                   data,
                                   option);
  }


  int
  my_plot_structure_ssv(std::string         filename,
                        std::string         sequence,
                        std::string         structure,
                        vrna_plot_layout_t  *layout = NULL,
                        vrna_plot_data_t    *data   = NULL)
  {
    return vrna_plot_structure_ssv(filename.c_str(),
                                   sequence.c_str(),
                                   structure.c_str(),
                                   layout,
                                   data);
  }


  int
  my_plot_structure_xrna(std::string        filename,
                         std::string        sequence,
                         std::string        structure,
                         vrna_plot_layout_t *layout = NULL,
                         vrna_plot_data_t   *data   = NULL)
  {
    return vrna_plot_structure_xrna(filename.c_str(),
                                    sequence.c_str(),
                                    structure.c_str(),
                                    layout,
                                    data);
  }




  int
  file_PS_aln(std::string               filename,
              std::vector<std::string>  alignment,
              std::vector<std::string>  identifiers,
              std::string               structure,
              unsigned int              start       = 0,
              unsigned int              end         = 0,
              int                       offset      = 0,
              unsigned int              columns     = 60)
  {
    std::vector<const char*> aln_vec;
    std::vector<const char*> id_vec;

    std::transform(alignment.begin(),
                   alignment.end(),
                   std::back_inserter(aln_vec),
                   convert_vecstring2veccharcp);

    std::transform(alignment.begin(),
                   alignment.end(),
                   std::back_inserter(id_vec),
                   convert_vecstring2veccharcp);

    aln_vec.push_back(NULL); /* mark end of sequences */
    id_vec.push_back(NULL); /* mark end of sequences */

    return vrna_file_PS_aln_slice(filename.c_str(),
                                  (const char **)&aln_vec[0],
                                  (const char **)&id_vec[0],
                                  structure.c_str(),
                                  start,
                                  end,
                                  offset,
                                  columns);
  }



  int
  plot_dp_EPS(std::string             filename,
              std::string             sequence,
              std::vector<vrna_ep_t>  upper_triangle,
              std::vector<vrna_ep_t>  lower_triangle = std::vector<vrna_ep_t>(),
              vrna_dotplot_auxdata_t  *auxdata = NULL,
              unsigned int            options = VRNA_PLOT_PROBABILITIES_DEFAULT)
  {
    vrna_ep_t               pp;

    if ((sequence.length() > 0) &&
        (filename.length() > 0)) {
      pp.i = pp.j = 0;
      pp.p = 0.;
      pp.type = VRNA_PLIST_TYPE_BASEPAIR;
      upper_triangle.push_back(pp);
      lower_triangle.push_back(pp);

      return vrna_plot_dp_EPS(filename.c_str(),
                              sequence.c_str(),
                              &upper_triangle[0],
                              &lower_triangle[0],
                              auxdata,
                              options);
    }

    return 0;
  }


  const unsigned int
  vrna_hc_t_n_get(vrna_hc_t *hc)
  {
    return hc->n;
  }

  var_array<unsigned char> *
  vrna_hc_t_mx_get(vrna_hc_t *hc)
  {
    return var_array_new(hc->n,
                         hc->mx,
                         VAR_ARRAY_SQR | VAR_ARRAY_ONE_BASED);
  }

  var_array<unsigned int> *
  vrna_hc_t_up_ext_get(vrna_hc_t *hc)
  {
    return var_array_new(hc->n,
                         hc->up_ext,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<unsigned int> *
  vrna_hc_t_up_hp_get(vrna_hc_t *hc)
  {
    return var_array_new(hc->n,
                         hc->up_hp,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<unsigned int> *
  vrna_hc_t_up_int_get(vrna_hc_t *hc)
  {
    return var_array_new(hc->n,
                         hc->up_int,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<unsigned int> *
  vrna_hc_t_up_ml_get(vrna_hc_t *hc)
  {
    return var_array_new(hc->n,
                         hc->up_ml,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

SWIGINTERN vrna_sc_mod_param_s *new_vrna_sc_mod_param_s(std::string json,vrna_md_t *md=NULL){
    /* try interpreting the json input as file name */
    vrna_sc_mod_param_s *obj = vrna_sc_mod_read_from_jsonfile(json.c_str(), md);

    if (obj == NULL)
      /* second guess is that the json string is actual json data */
      obj = vrna_sc_mod_read_from_json(json.c_str(), md);

    return obj;
  }
SWIGINTERN void delete_vrna_sc_mod_param_s(vrna_sc_mod_param_s *self){
    vrna_sc_mod_parameters_free(self);
  }

  vrna_sc_mod_param_t
  my_sc_mod_read_from_jsonfile(std::string  filename,
                               vrna_md_t    *md = NULL)
  {
    return vrna_sc_mod_read_from_jsonfile(filename.c_str(), md);
  }

  vrna_sc_mod_param_t
  my_sc_mod_read_from_json(std::string  json,
                           vrna_md_t    *md = NULL)
  {
    return vrna_sc_mod_read_from_json(json.c_str(), md);
  }


#include <stdexcept>

  typedef struct {
    PyObject  *f;
    PyObject  *data;
    PyObject  *delete_data;
  } py_probing_strategy_t;


  double *
  py_wrap_probing_strategy_callback(vrna_fold_compound_t *fc,
                                    const double         *data,
                                    size_t               data_size,
                                    unsigned int         target,
                                    void                 *options);


  static void
  delete_py_probing_strategy_data(py_probing_strategy_t *cb)
  {
    if ((cb->data != Py_None) &&
        (cb->delete_data != Py_None)) {
      PyObject *func, *arglist, *result, *err;
      func    = cb->delete_data;
      arglist = Py_BuildValue("O", cb->data);
      result  = PyObject_CallObject(func, arglist);

      /* BEGIN recognizing errors in callback execution */
      if (result == NULL) {
        if ((err = PyErr_Occurred())) {
          /* print error message */
          PyErr_Print();
          /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
          if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
            throw
            std::runtime_error(
              "Probing strategy option feee callback must take exactly 1 argument");


          else
            throw
            std::runtime_error(
              "Some error occurred while executing probing strategy option free callback");
        }

        PyErr_Clear();
      }

      /* END recognizing errors in callback execution */

      Py_DECREF(arglist);
      Py_XDECREF(result);
    }

    Py_DECREF(cb->data);
    Py_DECREF(cb->delete_data);
  }


  static void
  delete_py_probing_strategy_callback(void *data)
  {
    py_probing_strategy_t *cb = (py_probing_strategy_t *)data;

    /* first delete user data */
    delete_py_probing_strategy_data(cb);

    /* now dispose of the registered callbacks */
    Py_DECREF(cb->f);

    /* finally free pycallback */
    free(cb);
  }


  vrna_probing_data_t
  probing_data_linear(std::vector<double> data,
                      std::vector<double> data_weights,
                      PyObject            *strategy_cb,
                      PyObject            *strategy_cb_options = Py_None,
                      PyObject            *strategy_cb_options_free = Py_None,
                      unsigned int        options = VRNA_PROBING_DATA_DEFAULT)
  {
    unsigned char     func_is_tuple, func_is_list;
    unsigned int      s;
    py_probing_strategy_t *cb;

    if (!PyCallable_Check(strategy_cb)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object for argument strategy_cb!");
    } else if ((strategy_cb_options_free != Py_None) && (!PyCallable_Check(strategy_cb_options_free))) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object for argument strategy_cb_options_free!");
    } else {
      /* if we get to this point, at least cb is pointing to a callable object */
      cb = (py_probing_strategy_t *)vrna_alloc(sizeof(py_probing_strategy_t));

      cb->f = strategy_cb;                          /* remember callback */
      Py_INCREF(strategy_cb);                       /* Increase referenc counter */

      cb->delete_data = strategy_cb_options_free;   /* remember callback */
      Py_INCREF(strategy_cb_options_free);          /* Increase reference counter */

      cb->data = strategy_cb_options;               /* remember data */
      Py_INCREF(strategy_cb_options);               /* Increase reference counter */

      return vrna_probing_data_linear(&(data[0]),
                                      data.size() - 1,
                                      &(data_weights[0]),
                                      &py_wrap_probing_strategy_callback,
                                      (void *)cb,
                                      &delete_py_probing_strategy_callback,
                                      options);
    }

    return NULL;
  }


  double *
  py_wrap_probing_strategy_callback(vrna_fold_compound_t *fc,
                                    const double         *data,
                                    size_t               data_size,
                                    unsigned int         target,
                                    void                 *options)
  {
    double                  *ret;
    PyObject                *func, *arglist, *result, *err;
    py_probing_strategy_t   *cb = (py_probing_strategy_t *)options;

    ret   = NULL;
    func  = cb->f;

    /* compose argument list */
    PyObject *py_fc, *py_data, *py_data_size, *py_target;

    py_fc = SWIG_NewPointerObj(SWIG_as_voidptr(fc),
                               SWIGTYPE_p_vrna_fold_compound_t,
                               0);

    /* create PYTHON list for pr values */
    py_data = PyList_New((Py_ssize_t) data_size);

    /* 1-based data, so we add None as first element */
    PyList_SET_ITEM(py_data, (Py_ssize_t) 0, Py_None);

    /* actual values in range */
    for (size_t i = 1; i < data_size; i++)
      PyList_SET_ITEM(py_data, (Py_ssize_t) i, PyFloat_FromDouble(data[i]));

    py_data_size    = PyLong_FromLong(data_size);
    py_target       = PyLong_FromLong(target);
    result  = PyObject_CallFunctionObjArgs(func,
                                           py_fc,
                                           py_data,
                                           py_data_size,
                                           py_target,
                                           (cb->data) ? cb->data : Py_None, NULL);

    Py_DECREF(py_fc);
    Py_DECREF(py_data);
    Py_DECREF(py_data_size);
    Py_DECREF(py_target);

    if (result == Py_None) {
      ret = NULL;
    } else if (result == NULL) {
      /* BEGIN recognizing errors in callback execution */
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
          throw
          std::runtime_error(
            "Probing strategy callbacks must take exactly 5 arguments");


        else
          throw
          std::runtime_error(
            "Some error occurred while executing probing strategy callback");
      }

      PyErr_Clear();
    } else if (PyList_Check(result)) {
      ret = (double *)vrna_alloc(sizeof(double) * data_size);
      ret[0] = 0.;
      for (size_t i = 1; i < data_size; i++) {
        PyObject *v = PyList_GetItem(result, (Py_ssize_t)i);
        ret[i] = (PyFloat_Check(v)) ? PyFloat_AsDouble(v) : 0.;
      }
    } else if ((PyTuple_Check(result)) &&
               (PyTuple_Size(result) == (Py_ssize_t)data_size)) {
      ret = (double *)vrna_alloc(sizeof(double) * data_size);
      ret[0] = 0.;
      for (size_t i = 1; i < data_size; i++) {
        PyObject *v = PyTuple_GetItem(result, (Py_ssize_t)i);
        ret[i] = (PyFloat_Check(v)) ? PyFloat_AsDouble(v) : 0.;
      }
    } else {
      throw
      std::runtime_error(
        "Probing strategy callback must return a list or tuple of pseudo energy contributions");
    }

    /* END recognizing errors in callback execution */

    Py_XDECREF(result);

    return ret;
  }






#include <stdexcept>

typedef struct {
  PyObject *cb_trans;
  PyObject *cb_trans_data;
  PyObject *cb_trans_data_free;
} python_probing_data_trans_callback_t;

static python_probing_data_trans_callback_t *
bind_probing_data_trans_callback(PyObject *PyFunc,
                                 PyObject *data,
                                 PyObject *data_free_f);

/* TODO: change wrapper */
static double
python_wrap_probing_data_trans_cb(double                  reactivity,
                                  vrna_math_fun_dbl_opt_t data);

static void
delete_probing_data_trans(python_probing_data_trans_callback_t *cb)
{
  if(cb->cb_trans_data != Py_None){
    if(cb->cb_trans_data_free != Py_None){
      /* call user-defined data destructor */
      PyObject *func, *arglist, *result, *err;
      func = cb->cb_trans_data_free;
      arglist = Py_BuildValue("O", cb->cb_trans_data);
      result  = PyObject_CallObject(func, arglist);

      /* BEGIN recognizing errors in callback execution */
      if (result == NULL) {
        if ((err = PyErr_Occurred())) {
          /* print error message */
          PyErr_Print();
          /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
          if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
            throw std::runtime_error( "Probing data transform data free callback must take exactly 1 argument" );
          } else {
            throw std::runtime_error( "Some error occurred while executing probing data transform data free callback" );
          }
        }
        PyErr_Clear();
      }
      /* END recognizing errors in callback execution */

      Py_DECREF(arglist);
      Py_XDECREF(result);
    }
  }

  Py_DECREF(cb->cb_trans_data);
  Py_DECREF(cb->cb_trans_data_free);
}


static python_probing_data_trans_callback_t *
bind_probing_data_trans_callback(PyObject *transform_f,
                                 PyObject *data,
                                 PyObject *data_free_f)
{
  python_probing_data_trans_callback_t *cb = (python_probing_data_trans_callback_t *)vrna_alloc(sizeof(python_probing_data_trans_callback_t));

  if (transform_f != Py_None) {
    cb->cb_trans  = transform_f;
    Py_XINCREF(transform_f);
  } else {
    cb->cb_trans = NULL;
  }

  cb->cb_trans_data       = data;         /* remember data */
  cb->cb_trans_data_free  = data_free_f; /* remember delete data function */

  /* increase reference counter */
  Py_INCREF(data);
  Py_INCREF(data_free_f);

  return cb;
}

static void
release_probing_data_trans_callback(vrna_math_fun_dbl_opt_t data)
{
  python_probing_data_trans_callback_t *cb = (python_probing_data_trans_callback_t *)data;
  /* first delete user data */
  delete_probing_data_trans(cb);

  /* now dispose of the callback */
  Py_DECREF(cb->cb_trans);
  
  /* finally free pycallback */
  free(cb);
}


static double
python_wrap_probing_data_cb(double              reactivity,
                            vrna_math_fun_dbl_opt_t data)
{
  double ret;
  PyObject                  *arglist, *func, *result, *err;
  python_probing_data_trans_callback_t  *cb;

  cb    = (python_probing_data_trans_callback_t *)data;
  func  = cb->cb_trans;

  /* compose argument list */
  arglist = Py_BuildValue("(d,O)", reactivity, (cb->cb_trans_data) ? cb->cb_trans_data : Py_None);
  result =  PyObject_CallObject(func, arglist);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Reactivity transform_f callback must take exactly 1 argument" );
      } else {
        throw std::runtime_error( "Some error occurred while executing reactivity transform_f callback" );
      }
    }
    PyErr_Clear();
  } else if (PyFloat_Check(result)) {
    ret = (double)PyFloat_AsDouble(result);
  } else {
    throw
    std::runtime_error(
      "Reactivity transform_f callback must return value in double"
    );
  }
  /* END recognizing errors in callback execution */

  Py_DECREF(arglist);
  Py_XDECREF(result);

  return ret;
}


SWIGINTERN vrna_probing_data_s *new_vrna_probing_data_s__SWIG_0(std::vector< double,std::allocator< double > > reactivities,double m,double b,PyObject *transform_f=Py_None,PyObject *transform_data=Py_None,PyObject *data_free_f=Py_None){
    if (transform_f != Py_None) {
      python_probing_data_trans_callback_t  *cb = bind_probing_data_trans_callback(transform_f,
                                                                                   transform_data,
                                                                                   data_free_f);

      return vrna_probing_data_deigan_trans(&(reactivities[0]),
                                            reactivities.size(),
                                            m,
                                            b,
                                            python_wrap_probing_data_cb,
                                            (vrna_math_fun_dbl_opt_t)cb,
                                            release_probing_data_trans_callback);
    } else {
      return vrna_probing_data_deigan(&(reactivities[0]),
                                      reactivities.size(),
                                      m,
                                      b);
    }
  }
SWIGINTERN vrna_probing_data_s *new_vrna_probing_data_s__SWIG_1(std::vector< double,std::allocator< double > > reactivities,double beta,std::string pr_conversion=VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion,double pr_default=VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability){
    return vrna_probing_data_zarringhalam(&(reactivities[0]),
                                          reactivities.size(),
                                          beta,
                                          pr_conversion.c_str(),
                                          pr_default);
  }
SWIGINTERN vrna_probing_data_s *new_vrna_probing_data_s__SWIG_2(std::vector< double,std::allocator< double > > reactivities,double temperature,unsigned int options=VRNA_PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT,std::vector< double,std::allocator< double > > unpaired_data={},std::vector< double,std::allocator< double > > paired_data={},PyObject *transform_f=Py_None,PyObject *transform_data=Py_None,PyObject *data_free_f=Py_None){
    if (transform_f != Py_None) {
      python_probing_data_trans_callback_t  *cb = bind_probing_data_trans_callback(transform_f,
                                                                                   transform_data,
                                                                                   data_free_f);

      return vrna_probing_data_eddy_trans(&(reactivities[0]),
                                          reactivities.size(),
                                          temperature,
                                          options,
                                          &(unpaired_data[0]),
                                          unpaired_data.size(),
                                          &(paired_data[0]),
                                          paired_data.size(),
                                          python_wrap_probing_data_cb,
                                          (vrna_math_fun_dbl_opt_t) cb,
                                          release_probing_data_trans_callback);
    } else {
      return vrna_probing_data_eddy(&(reactivities[0]),
                                    reactivities.size(),
                                    temperature,
                                    options,
                                    &(unpaired_data[0]),
                                    unpaired_data.size(),
                                    &(paired_data[0]),
                                    paired_data.size());
    }
  }
SWIGINTERN vrna_probing_data_s *new_vrna_probing_data_s__SWIG_3(std::vector< double,std::allocator< double > > reactivities,double m,double b){
    vrna_probing_data_s *obj = vrna_probing_data_deigan(&(reactivities[0]),
                                                        reactivities.size() - 1,
                                                        m,
                                                        b);
    return obj;
  }
SWIGINTERN vrna_probing_data_s *new_vrna_probing_data_s__SWIG_4(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > reactivities,std::vector< double,std::allocator< double > > ms,std::vector< double,std::allocator< double > > bs){
    unsigned int              n_seq = reactivities.size();
    std::vector<unsigned int> ns;
    vrna_probing_data_s       *obj;
    double                    **d;

    for (unsigned int i = 0; i < reactivities.size(); i++)
      ns.push_back(reactivities[i].size() - 1);

    unsigned int options = VRNA_PROBING_METHOD_MULTI_PARAMS_0;
    if (ms.size() > 1)
      options |= VRNA_PROBING_METHOD_MULTI_PARAMS_1;

    if (bs.size() > 1)
      options |= VRNA_PROBING_METHOD_MULTI_PARAMS_2;

    d = (double **)vrna_alloc(sizeof(double *) * reactivities.size());
    for (unsigned int i = 0; i < reactivities.size(); i++)
      if (reactivities[i].size() > 0) {
        d[i] = (double *)vrna_alloc(sizeof(double) * reactivities[i].size());
        d[i] = (double *)memcpy(d[i], &(reactivities[i][0]), sizeof(double) * reactivities[i].size());
      }

    /* try interpreting the json input as file name */
    obj = vrna_probing_data_deigan_comparative((const double **)d,
                                               &(ns[0]),
                                               reactivities.size(),
                                               &(ms[0]),
                                               &(bs[0]),
                                               options);

    for (unsigned int i = 0; i < reactivities.size(); i++)
      free(d[i]);
    free(d);

    return obj;
  }
SWIGINTERN vrna_probing_data_s *new_vrna_probing_data_s__SWIG_5(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > reactivities,std::vector< double,std::allocator< double > > betas,std::vector< std::string,std::allocator< std::string > > pr_conversions=std::vector< std::string >(),std::vector< double,std::allocator< double > > pr_defaults=std::vector< double >()){
    unsigned int              n_seq = reactivities.size();
    std::vector<unsigned int> ns;
    vrna_probing_data_s       *obj;
    double                    **d;
    char                      **c;

    if (pr_conversions.size() == 0)
      pr_conversions.push_back(VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion);

    if (pr_defaults.size() == 0)
      pr_defaults.push_back(VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability);

    for (unsigned int i = 0; i < reactivities.size(); i++)
      ns.push_back(reactivities[i].size() - 1);

    unsigned int options = VRNA_PROBING_METHOD_MULTI_PARAMS_0;
    if (betas.size() > 1)
      options |= VRNA_PROBING_METHOD_MULTI_PARAMS_1;

    if (pr_conversions.size() > 1)
      options |= VRNA_PROBING_METHOD_MULTI_PARAMS_2;

    if (pr_defaults.size() > 1)
      options |= VRNA_PROBING_METHOD_MULTI_PARAMS_3;

    c = (char **)vrna_alloc(sizeof(char *) * pr_conversions.size());
    for (unsigned int i = 0; i < pr_conversions.size(); i++)
      if (pr_conversions[i].size() > 0) {
        c[i] = (char *)vrna_alloc(sizeof(char) * (pr_conversions[i].size() + 1));
        c[i] = (char *)memcpy(c[i], pr_conversions[i].c_str(), sizeof(char *) * (pr_conversions[i].size() + 1));
      }

    d = (double **)vrna_alloc(sizeof(double *) * reactivities.size());
    for (unsigned int i = 0; i < reactivities.size(); i++)
      if (reactivities[i].size() > 0) {
        d[i] = (double *)vrna_alloc(sizeof(double) * reactivities[i].size());
        d[i] = (double *)memcpy(d[i], &(reactivities[i][0]), sizeof(double) * reactivities[i].size());
      }

    /* try interpreting the json input as file name */
    obj = vrna_probing_data_zarringhalam_comparative((const double **)d,
                                                     &(ns[0]),
                                                     reactivities.size(),
                                                     &(betas[0]),
                                                     (const char **)c,
                                                     &(pr_defaults[0]),
                                                     options);

    for (unsigned int i = 0; i < reactivities.size(); i++) {
      free(d[i]);
      free(c[i]);
    }
    free(d);
    free(c);

    return obj;
  }
SWIGINTERN vrna_probing_data_s *new_vrna_probing_data_s__SWIG_6(std::vector< double,std::allocator< double > > reactivities,double temperature,unsigned char options,std::vector< double,std::allocator< double > > unpaired_data={},std::vector< double,std::allocator< double > > paired_data={}){
    vrna_probing_data_s *obj = vrna_probing_data_eddy(&(reactivities[0]),
                                                      reactivities.size(),
                                                      temperature,
                                                      options,
                                                      &(unpaired_data[0]),
                                                      unpaired_data.size(),
                                                      &(paired_data[0]),
                                                      paired_data.size());
    return obj;
  }
SWIGINTERN void delete_vrna_probing_data_s(vrna_probing_data_s *self){
    vrna_probing_data_free(self);
  }
SWIGINTERN unsigned int vrna_probing_data_s_probing_data_linear_num(vrna_probing_data_s *self){
    return vrna_probing_data_linear_num(self);
  }
SWIGINTERN std::vector< double,std::allocator< double > > vrna_probing_data_s_probing_data_linear_raw(vrna_probing_data_s *self,unsigned int pos){
    unsigned int        s;
    double              *r;
    std::vector<double> rv;

    r = vrna_probing_data_linear_raw(self,
                                     pos,
                                     &s);

    if (r)
      rv = std::vector<double>(r, r + s);

    free(r);

    return rv;
  }
SWIGINTERN std::vector< double,std::allocator< double > > vrna_probing_data_s_probing_data_linear_weight(vrna_probing_data_s *self,unsigned int pos){
    unsigned int        s;
    double              *w;
    std::vector<double> wv;

    w = vrna_probing_data_linear_weight(self,
                                        pos,
                                        &s);

    if (w)
      wv = std::vector<double>(w, w + s);

    free(w);

    return wv;
  }
SWIGINTERN std::vector< double,std::allocator< double > > vrna_probing_data_s_probing_data_linear_energies(vrna_probing_data_s *self,unsigned int pos,vrna_fold_compound_t *fc,unsigned int target){
    unsigned int        s;
    double              *e;
    std::vector<double> ev;

    e = vrna_probing_data_linear_energies(self,
                                          pos,
                                          fc,
                                          target,
                                          &s);

    if (e)
      ev = std::vector<double>(e, e + s);

    free(e);

    return ev;
  }

#include <vector>

  vrna_probing_data_s *
  probing_data_deigan(std::vector<double> reactivities,
                      double              m,
                      double              b)
  {
    vrna_probing_data_s *obj = vrna_probing_data_deigan(&(reactivities[0]),
                                                        reactivities.size() - 1,
                                                        m,
                                                        b);
    return obj;
  }


  vrna_probing_data_s *
  probing_data_deigan_comparative(std::vector<std::vector<double> > reactivities,
                                  std::vector<double>               ms,
                                  std::vector<double>               bs,
                                  unsigned int                      multi_params = VRNA_PROBING_METHOD_MULTI_PARAMS_0)
  {
    unsigned int              n_seq = reactivities.size();
    std::vector<unsigned int> ns;
    vrna_probing_data_s       *obj;
    double                    **d;

    for (unsigned int i = 0; i < reactivities.size(); i++)
      ns.push_back(reactivities[i].size() - 1);

    d = (double **)vrna_alloc(sizeof(double *) * reactivities.size());
    for (unsigned int i = 0; i < reactivities.size(); i++)
      if (reactivities[i].size() > 0) {
        d[i] = (double *)vrna_alloc(sizeof(double) * reactivities[i].size());
        d[i] = (double *)memcpy(d[i], &(reactivities[i][0]), sizeof(double) * reactivities[i].size());
      }

    /* try interpreting the json input as file name */
    obj = vrna_probing_data_deigan_comparative((const double **)d,
                                               &(ns[0]),
                                               n_seq,
                                               &(ms[0]),
                                               &(bs[0]),
                                               multi_params);

    for (unsigned int i = 0; i < reactivities.size(); i++)
      free(d[i]);
    free(d);

    return obj;
  }


  vrna_probing_data_s *
  probing_data_zarringhalam(std::vector<double> reactivities,
                            double              beta,
                            std::string         pr_conversion = VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion,
                            double              pr_default    = VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability)
  {
    vrna_probing_data_s *obj = vrna_probing_data_zarringhalam(&(reactivities[0]),
                                                              reactivities.size() - 1,
                                                              beta,
                                                              pr_conversion.c_str(),
                                                              pr_default);
    return obj;
  }


  vrna_probing_data_s *
  probing_data_zarringhalam_comparative(std::vector< std::vector<double> > reactivities,
                                        std::vector<double>              betas,
                                        std::vector<std::string>         pr_conversions = std::vector<std::string>(),
                                        std::vector<double>              pr_defaults = std::vector<double>(),
                                        unsigned int                     multi_params = VRNA_PROBING_METHOD_MULTI_PARAMS_0)
  {
    unsigned int              n_seq = reactivities.size();
    std::vector<unsigned int> ns;
    vrna_probing_data_s       *obj;
    double                    **d;
    char                      **c;

    if (pr_conversions.size() == 0)
      pr_conversions.push_back(VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion);

    if (pr_defaults.size() == 0)
      pr_defaults.push_back(VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability);

    for (unsigned int i = 0; i < reactivities.size(); i++)
      ns.push_back(reactivities[i].size() - 1);

    c = (char **)vrna_alloc(sizeof(char *) * pr_conversions.size());
    for (unsigned int i = 0; i < pr_conversions.size(); i++)
      if (pr_conversions[i].size() > 0) {
        c[i] = (char *)vrna_alloc(sizeof(char) * (pr_conversions[i].size() + 1));
        c[i] = (char *)memcpy(c[i], pr_conversions[i].c_str(), sizeof(char *) * (pr_conversions[i].size() + 1));
      }

    d = (double **)vrna_alloc(sizeof(double *) * reactivities.size());
    for (unsigned int i = 0; i < reactivities.size(); i++)
      if (reactivities[i].size() > 0) {
        d[i] = (double *)vrna_alloc(sizeof(double) * reactivities[i].size());
        d[i] = (double *)memcpy(d[i], &(reactivities[i][0]), sizeof(double) * reactivities[i].size());
      }

    /* try interpreting the json input as file name */
    obj = vrna_probing_data_zarringhalam_comparative((const double **)d,
                                                     &(ns[0]),
                                                     reactivities.size(),
                                                     &(betas[0]),
                                                     (const char **)c,
                                                     &(pr_defaults[0]),
                                                     multi_params);

    for (unsigned int i = 0; i < reactivities.size(); i++) {
      free(d[i]);
      free(c[i]);
    }
    free(d);
    free(c);

    return obj;
  }


  vrna_probing_data_s *
  probing_data_eddy(std::vector<double> reactivities,
                    double              temperature,
                    unsigned char       options = VRNA_PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT,
                    std::vector<double> unpaired_data = {},
                    std::vector<double> paired_data = {})
  {
    vrna_probing_data_s *obj = vrna_probing_data_eddy(&(reactivities[0]),
                                                      reactivities.size() - 1,
                                                      temperature,
                                                      options,
                                                      &(unpaired_data[0]),
                                                      unpaired_data.size(),
                                                      &(paired_data[0]),
                                                      paired_data.size());
    return obj;
  }


  vrna_probing_data_s *
  probing_data_eddy_comparative(std::vector< std::vector<double> >  reactivities,
                                double                              temperature,
                                unsigned char                       options = VRNA_PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT,
                                std::vector< std::vector<double> >  unpaired_data = {},
                                std::vector< std::vector<double> >  paired_data = {},
                                unsigned int                        multi_params = VRNA_PROBING_METHOD_MULTI_PARAMS_0)
  {
    unsigned int              n_seq = reactivities.size();
    std::vector<unsigned int> ns;
    std::vector<unsigned int> us;
    std::vector<unsigned int> bs;
    vrna_probing_data_s       *obj;
    double                    **d;
    double                    **up;
    double                    **bp;

    for (unsigned int i = 0; i < reactivities.size(); i++) {
      ns.push_back(reactivities[i].size() - 1);
      us.push_back(unpaired_data[i].size());
      bs.push_back(paired_data[i].size());
    }

    up = (double **)vrna_alloc(sizeof(double *) * unpaired_data.size());
    for (unsigned int i = 0; i < unpaired_data.size(); i++)
      if (unpaired_data[i].size() > 0) {
        up[i] = (double *)vrna_alloc(sizeof(double) * (unpaired_data[i].size() + 1));
        up[i] = (double *)memcpy(up[i], &(unpaired_data[i][0]), sizeof(double *) * (unpaired_data[i].size() + 1));
      }

    bp = (double **)vrna_alloc(sizeof(double *) * paired_data.size());
    for (unsigned int i = 0; i < paired_data.size(); i++)
      if (paired_data[i].size() > 0) {
        bp[i] = (double *)vrna_alloc(sizeof(double) * (paired_data[i].size() + 1));
        bp[i] = (double *)memcpy(bp[i], &(paired_data[i][0]), sizeof(double *) * (paired_data[i].size() + 1));
      }

    d = (double **)vrna_alloc(sizeof(double *) * reactivities.size());
    for (unsigned int i = 0; i < reactivities.size(); i++)
      if (reactivities[i].size() > 0) {
        d[i] = (double *)vrna_alloc(sizeof(double) * reactivities[i].size());
        d[i] = (double *)memcpy(d[i], &(reactivities[i][0]), sizeof(double) * reactivities[i].size());
      }

    /* try interpreting the json input as file name */
    obj = vrna_probing_data_eddy_comparative((const double **)d,
                                              &(ns[0]),
                                              n_seq,
                                              temperature,
                                              options,
                                              (const double **)up,
                                              &(us[0]),
                                              (const double **)bp,
                                              &(bs[0]),
                                              multi_params);

    for (unsigned int i = 0; i < reactivities.size(); i++) {
      free(d[i]);
      free(up[i]);
      free(bp[i]);
    }
    free(d);
    free(up);
    free(bp);

    return obj;
  }




  float
  my_eval_structure_simple(std::string sequence,
                           std::string structure,
                           int         verbosity_level = VRNA_VERBOSITY_QUIET,
                           FILE        *nullfile = NULL)
  {
    return vrna_eval_structure_simple_v(sequence.c_str(), structure.c_str(), verbosity_level, nullfile);
  }

  float
  my_eval_circ_structure(std::string sequence,
                         std::string structure,
                         int         verbosity_level = VRNA_VERBOSITY_QUIET,
                         FILE        *nullfile = NULL)
  {
    return vrna_eval_circ_structure_v(sequence.c_str(), structure.c_str(), verbosity_level, nullfile);
  }

  float
  my_eval_gquad_structure(std::string sequence,
                          std::string structure,
                          int         verbosity_level = VRNA_VERBOSITY_QUIET,
                          FILE        *nullfile = NULL)
  {
    return vrna_eval_gquad_structure_v(sequence.c_str(), structure.c_str(), verbosity_level, nullfile);
  }

  float
  my_eval_circ_gquad_structure(std::string sequence,
                               std::string structure,
                               int         verbosity_level = VRNA_VERBOSITY_QUIET,
                               FILE        *nullfile = NULL)
  {
    return vrna_eval_circ_gquad_structure_v(sequence.c_str(), structure.c_str(), verbosity_level, nullfile);
  }

  float
  my_eval_structure_simple(std::vector<std::string> alignment,
                           std::string              structure,
                           int                      verbosity_level = VRNA_VERBOSITY_QUIET,
                           FILE                     *nullfile = NULL)
  {
    std::vector<const char*>  vc;

    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    return vrna_eval_consensus_structure_simple_v((const char **)&vc[0], structure.c_str(), verbosity_level, nullfile);
  }

  float
  my_eval_circ_structure(std::vector<std::string> alignment,
                         std::string              structure,
                         int                      verbosity_level = VRNA_VERBOSITY_QUIET,
                         FILE                     *nullfile = NULL)
  {
    std::vector<const char*>  vc;

    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    return vrna_eval_circ_consensus_structure_v((const char **)&vc[0], structure.c_str(), verbosity_level, nullfile);
  }

  float
  my_eval_gquad_structure(std::vector<std::string>  alignment,
                          std::string               structure,
                          int                       verbosity_level = VRNA_VERBOSITY_QUIET,
                          FILE                      *nullfile = NULL)
  {
    std::vector<const char*>  vc;

    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    return vrna_eval_gquad_consensus_structure_v((const char **)&vc[0], structure.c_str(), verbosity_level, nullfile);
  }

  float
  my_eval_circ_gquad_structure(std::vector<std::string> alignment,
                               std::string              structure,
                               int                      verbosity_level = VRNA_VERBOSITY_QUIET,
                               FILE                     *nullfile = NULL)
  {
    std::vector<const char*>  vc;

    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    return vrna_eval_circ_gquad_consensus_structure_v((const char **)&vc[0], structure.c_str(), verbosity_level, nullfile);
  }

  int
  my_eval_structure_pt_simple(std::string       sequence,
                              std::vector<int>  pt,
                              int               verbosity_level = VRNA_VERBOSITY_QUIET,
                              FILE              *nullfile = NULL)
  {
    std::vector<short> vc;

    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);

    return vrna_eval_structure_pt_simple_v(sequence.c_str(), (const short*)&vc[0], verbosity_level, nullfile);
  }

  int
  my_eval_structure_pt_simple(std::string       sequence,
                              var_array<short> const &pt,
                              int               verbosity_level = VRNA_VERBOSITY_QUIET,
                              FILE              *nullfile = NULL)
  {
    return vrna_eval_structure_pt_simple_v(sequence.c_str(), pt.data, verbosity_level, nullfile);
  }

  int
  my_eval_structure_pt_simple(std::vector<std::string>  alignment,
                              std::vector<int>          pt,
                              int                       verbosity_level = VRNA_VERBOSITY_QUIET,
                              FILE                      *nullfile = NULL)
  {
    std::vector<const char*>  vc;
    std::vector<short> ptv;

    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    transform(pt.begin(), pt.end(), back_inserter(ptv), convert_vecint2vecshort);

    return vrna_eval_consensus_structure_pt_simple_v((const char **)&vc[0], (const short*)&ptv[0], verbosity_level, nullfile);
  }

  int
  my_eval_structure_pt_simple(std::vector<std::string>  alignment,
                              var_array<short> const   &pt,
                              int                       verbosity_level = VRNA_VERBOSITY_QUIET,
                              FILE                      *nullfile = NULL)
  {
    std::vector<const char*>  vc;

    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    return vrna_eval_consensus_structure_pt_simple_v((const char **)&vc[0], pt.data, verbosity_level, nullfile);
  }



  int
  my_maximum_matching(std::string sequence)
  {
    return vrna_maximum_matching_simple(sequence.c_str());
  }



#include <string>
#include <cstring>
#include <vector>

  char *
  my_fold(char *string,
          float *energy)
  {
    char *struc;

    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    *energy = vrna_fold(string, struc);

    return struc;
  }

  char *
  my_fold(char *string,
          char *constraints,
          float *energy)
  {
    char                  *struc;
    vrna_fold_compound_t  *fc;

    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    fc    = vrna_fold_compound(string, NULL, VRNA_OPTION_DEFAULT);

    if (constraints && fold_constrained)
      vrna_hc_add_from_db(fc, constraints, VRNA_CONSTRAINT_DB_DEFAULT);

    *energy = vrna_mfe(fc, struc);

    vrna_fold_compound_free(fc);

#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    if (constraints && (!fold_constrained))
      strncpy(constraints, struc, strlen(constraints));
#endif

    return struc;
  }

  char *
  my_alifold(std::vector<std::string> alignment,
             float                    *energy)
  {
    char *struc;
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  vc;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    struc = (char *)calloc(strlen(vc[0])+1,sizeof(char));

    *energy = vrna_alifold((const char **)&vc[0], struc);

    return struc;
  }

  char *
  my_alifold(std::vector<std::string> alignment,
             char                     *constraints,
             float                    *energy)
  {
    char                      *struc;
    vrna_fold_compound_t      *fc;
    std::vector<const char*>  vc;

    /* convert std::vector<std::string> to vector<const char *> */
    std::transform(alignment.begin(),
                   alignment.end(),
                   std::back_inserter(vc),
                   convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    struc = (char *)calloc(strlen(vc[0])+1,sizeof(char));

    fc = vrna_fold_compound_comparative((const char **)&vc[0], NULL, VRNA_OPTION_DEFAULT);

    if (constraints && fold_constrained)
      vrna_hc_add_from_db(fc, constraints, VRNA_CONSTRAINT_DB_DEFAULT);

    *energy = vrna_mfe(fc, struc);

    vrna_fold_compound_free(fc);

#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    if (constraints && (!fold_constrained))
      strncpy(constraints, struc, strlen(constraints));
#endif

    return struc;
  }

  char *
  my_cofold(char  *string,
            float *energy)
  {
    char *s, **tok, **ptr, *struc, *sequence;

    sequence = string;
    struc    = (char *)calloc(strlen(string)+1,sizeof(char));

#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    /* first, tokenize the input at delimiter '&' */
    tok = vrna_strsplit(string, "&");

    /*
        now, check whether there is only a single sequence.
        This may be a hint that someone is still using the
        'old' API where the split point had to be spliced out
        and explicitly specified through the global variable
        cut_point
     */
    if ((tok) && (tok[0])) {
      if (!tok[1]) {
        if (cut_point > (int)strlen(string)) {
          cut_point = -1;
        } else {
          /* we need to re-insert the delimiter now */
          sequence = vrna_cut_point_insert(string, cut_point);
        }
      }
    }
#endif

    *energy = vrna_cofold(sequence, struc);

#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    /* clean up */
    if (tok) {
      for (ptr = tok; *ptr; ptr++)
        free(*ptr);

      free(tok);
    }

    if (sequence != string)
      free(sequence);
#endif

    return struc;
  }

  char *
  my_cofold(char  *string,
            char  *constraints,
            float *energy)
  {
    char *s, **tok, **ptr, *struc, *sequence;
    vrna_fold_compound_t      *fc;

    sequence = string;
    struc    = (char *)calloc(strlen(string)+1,sizeof(char));

#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    /* first, tokenize the input at delimiter '&' */
    tok = vrna_strsplit(string, "&");

    /*
        now, check whether there is only a single sequence.
        This may be a hint that someone is still using the
        'old' API where the split point had to be spliced out
        and explicitly specified through the global variable
        cut_point
     */
    if ((tok) && (tok[0])) {
      if (!tok[1]) {
        if (cut_point > (int)strlen(string)) {
          cut_point = -1;
        } else {
          /* we need to re-insert the delimiter now */
          sequence = vrna_cut_point_insert(string, cut_point);
        }
      }
    }
#endif

    fc = vrna_fold_compound(sequence, NULL, VRNA_OPTION_DEFAULT);

    if (constraints && fold_constrained)
      vrna_hc_add_from_db(fc, constraints, VRNA_CONSTRAINT_DB_DEFAULT);

    *energy = vrna_mfe_dimer(fc, struc);

    /* clean up */
#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    if (tok) {
      for (ptr = tok; *ptr; ptr++)
        free(*ptr);

      free(tok);
    }

    if (sequence != string)
      free(sequence);
#endif

    vrna_fold_compound_free(fc);

#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    if (constraints && (!fold_constrained))
      strncpy(constraints, struc, strlen(constraints));
#endif

    return struc;
  }

  char *
  my_circfold(char *string,
              float *energy)
  {
    char *struc;

    struc   = (char *)calloc(strlen(string)+1,sizeof(char));
    *energy = vrna_circfold(string, struc);

    return struc;
  }

  char *
  my_circfold(char *string,
              char *constraints,
              float *energy)
  {
    char                  *struc;
    vrna_md_t             md;
    vrna_fold_compound_t  *fc;

    vrna_md_set_default(&md);
    md.circ = 1;

    struc = (char *)calloc(strlen(string)+1,sizeof(char));

    fc  = vrna_fold_compound(string, &md, VRNA_OPTION_DEFAULT);

    if (constraints && fold_constrained)
      vrna_hc_add_from_db(fc, constraints, VRNA_CONSTRAINT_DB_DEFAULT);

    *energy = vrna_mfe(fc, struc);

    vrna_fold_compound_free(fc);

#ifndef VRNA_DISABLE_BACKWARD_COMPATIBILITY
    if (constraints && (!fold_constrained))
      strncpy(constraints, struc, strlen(constraints));
#endif

    return struc;
  }

  char *
  my_circalifold(std::vector<std::string> alignment,
                 float                    *energy)
  {
    char *struc;
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  vc;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    struc = (char *)calloc(strlen(vc[0])+1,sizeof(char));

    *energy = vrna_circalifold((const char **)&vc[0], struc);

    return struc;
  }

  char *
  my_circalifold(std::vector<std::string> alignment,
                 char                     *constraints,
                 float                    *energy)
  {
    char                      *struc;
    vrna_fold_compound_t      *fc;
    std::vector<const char*>  vc;
    vrna_md_t                 md;

    vrna_md_set_default(&md);
    md.circ = 1;

    /* convert std::vector<std::string> to vector<const char *> */
    std::transform(alignment.begin(),
                   alignment.end(),
                   std::back_inserter(vc),
                   convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */

    struc = (char *)calloc(strlen(vc[0])+1,sizeof(char));

    fc = vrna_fold_compound_comparative((const char **)&vc[0],
                                        &md,
                                        VRNA_OPTION_DEFAULT);

    if (constraints && fold_constrained)
      vrna_hc_add_from_db(fc, constraints, VRNA_CONSTRAINT_DB_DEFAULT);

    *energy = vrna_mfe(fc, struc);

    vrna_fold_compound_free(fc);

    return struc;
  }




#ifdef VRNA_WITH_SVM
  float
  my_Lfoldz(std::string sequence,
            int         window_size,
            double      min_z,
            FILE        *nullfile = NULL)
  {
    return vrna_Lfoldz(sequence.c_str(),
                       window_size,
                       min_z,
                       nullfile);
  }
#endif

  float
  my_Lfold(std::string sequence,
           int        window_size,
           FILE       *nullfile = NULL)
  {
    return vrna_Lfold(sequence.c_str(), window_size, nullfile);
  }

  float
  my_aliLfold(std::vector<std::string> alignment,
              int                      window_size,
              FILE                     *nullfile = NULL)
  {
    /* convert std::vector<std::string> to vector<const char *> */
    std::vector<const char*>  aln;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(aln), convert_vecstring2veccharcp);
    aln.push_back(NULL); /* mark end of sequences */

    return vrna_aliLfold((const char **)&aln[0],
                         window_size,
                         nullfile);
  }



  char *
  my_pf_fold(char   *string,
             float  *energy)
  {
    char *struc;
    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    *energy = pf_fold(string, struc);
    return(struc);
  }

  char *
  my_pf_fold(char *string,
             char *constraints,
             float *energy)
  {
    char *struc;
    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    if (constraints && fold_constrained)
      strncpy(struc, constraints, strlen(string));
    *energy = pf_fold(string, struc);
    if (constraints)
      strncpy(constraints, struc, strlen(constraints));
    return(struc);
  }


  char *
  my_pf_circ_fold(char  *string,
                  float *energy)
  {
    char *struc;
    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    *energy = pf_circ_fold(string, struc);
    return(struc);
  }

  char *
  my_pf_circ_fold(char  *string,
                  char  *constraints,
                  float *energy)
  {
    char *struc;
    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    if (constraints && fold_constrained)
      strncpy(struc, constraints, strlen(string));
    *energy = pf_circ_fold(string, struc);
    if (constraints)
      strncpy(constraints, struc, strlen(constraints));
    return(struc);
  }


  double
  my_pf_add(double dG1,
            double dG2,
            double kT = 0) {
    double result = 0;

    if (kT == 0)
      kT = (37. + K0) * GASCONST / 1000.;

    return (double)vrna_pf_add((FLT_OR_DBL)(dG1), (FLT_OR_DBL)(dG2), kT);
  }


  char *
  my_co_pf_fold(char  *string,
                float *FA,
                float *FB,
                float *FcAB,
                float *FAB)
  {
    char *struc;
    vrna_dimer_pf_t temp;
    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    temp=co_pf_fold(string, struc);
    *FAB = temp.FAB;
    *FcAB = temp.FcAB;
    *FA = temp.FA;
    *FB = temp.FB;
    return(struc);
  }
  char *
  my_co_pf_fold(char  *string,
                char  *constraints,
                float *FA,
                float *FB,
                float *FcAB,
                float *FAB)
  {
    char *struc;
    vrna_dimer_pf_t temp;
    struc = (char *)calloc(strlen(string)+1,sizeof(char));
    if (constraints && fold_constrained)
      strncpy(struc, constraints, strlen(string));
    temp=co_pf_fold(string, struc);
    *FAB = temp.FAB;
    *FcAB = temp.FcAB;
    *FA = temp.FA;
    *FB = temp.FB;
    if (constraints)
      strncpy(constraints, struc, strlen(constraints));
    return(struc);
  }


double
get_pr(int i,
       int j)
{
  int ii;
  if (i>j) {ii=i; i=j; j=ii;}
  return pr[iindx[i]-j];
}


  char *
  my_MEA_from_plist(std::vector<vrna_ep_t> plist,
                    std::string            sequence,
                    double                 gamma,
                    vrna_md_t              *md,
                    float                  *OUTPUT)
  {
    vrna_ep_t               pp;
    std::vector<vrna_ep_t>  pl = plist;

    pp.i = pp.j = 0;
    pp.p = 0.;
    pp.type = VRNA_PLIST_TYPE_BASEPAIR;
    pl.push_back(pp);

    return vrna_MEA_from_plist(&pl[0],
                               sequence.c_str(),
                               gamma,
                               md,
                               OUTPUT);
  }

  char *
  my_MEA_from_plist(std::vector<vrna_ep_t> plist,
                    std::string            sequence,
                    vrna_md_t              *md,
                    float                  *OUTPUT)
  {
    vrna_ep_t               pp;
    std::vector<vrna_ep_t>  pl = plist;

    pp.i = pp.j = 0;
    pp.p = 0.;
    pp.type = VRNA_PLIST_TYPE_BASEPAIR;
    pl.push_back(pp);

    return vrna_MEA_from_plist(&pl[0],
                               sequence.c_str(),
                               1.,
                               md,
                               OUTPUT);
  }

  char *
  my_MEA_from_plist(std::vector<vrna_ep_t> plist,
                    std::string            sequence,
                    double                 gamma,
                    float                  *OUTPUT)
  {
    vrna_ep_t               pp;
    std::vector<vrna_ep_t>  pl = plist;

    pp.i = pp.j = 0;
    pp.p = 0.;
    pp.type = VRNA_PLIST_TYPE_BASEPAIR;
    pl.push_back(pp);

    return vrna_MEA_from_plist(&pl[0],
                               sequence.c_str(),
                               gamma,
                               NULL,
                               OUTPUT);
  }

  char *
  my_MEA_from_plist(std::vector<vrna_ep_t> plist,
                    std::string            sequence,
                    float                  *OUTPUT)
  {
    vrna_ep_t               pp;
    std::vector<vrna_ep_t>  pl = plist;

    pp.i = pp.j = 0;
    pp.p = 0.;
    pp.type = VRNA_PLIST_TYPE_BASEPAIR;
    pl.push_back(pp);

    return vrna_MEA_from_plist(&pl[0],
                               sequence.c_str(),
                               1.,
                               NULL,
                               OUTPUT);
  }


SWIGINTERN vrna_pbacktrack_mem_t *new_vrna_pbacktrack_mem_t(){
    vrna_pbacktrack_mem_t *m = (vrna_pbacktrack_mem_t *)vrna_alloc(sizeof(vrna_pbacktrack_mem_t));
    *m = NULL;
    return m;
  }
SWIGINTERN void delete_vrna_pbacktrack_mem_t(vrna_pbacktrack_mem_t *self){
    vrna_pbacktrack_mem_free(*self);
    delete self;
  }

#include <vector>

  std::vector<vrna_ep_t>
  my_pfl_fold(std::string sequence,
              int         w,
              int         L,
              double      cutoff)
  {
    std::vector<vrna_ep_t > vplist;
    vrna_ep_t *ptr, *plist;

    plist = vrna_pfl_fold(sequence.c_str(), w, L, (float)cutoff);

    for (ptr = plist; ptr->i && ptr->j; ptr++) {
      vrna_ep_t pl;
      pl.i    = ptr->i;
      pl.j    = ptr->j;
      pl.p    = ptr->p;
      pl.type = ptr->type;
      vplist.push_back(pl);
    }
    free(plist);

    return vplist;
  }

  std::vector<std::vector<double> >
  pfl_fold_up(std::string sequence,
               int        ulength,
               int        window_size,
               int        max_bp_span)
  {
    double **up = vrna_pfl_fold_up(sequence.c_str(), ulength, window_size, max_bp_span);

    std::vector<std::vector<double> > up_vec;

    std::vector<double> nullvec(ulength + 1, 0.);

    /* insert a 0th element, since we start a 1-based N x M matrix here */
    up_vec.push_back(nullvec);
    free(up[0]);
    for (unsigned int i = 1; i <= sequence.length(); i++) {
      std::vector<double> row;
      /* insert a 0th element, again, everything should be 1-based */
      row.push_back(0.);

      /* add remaining elements for this row */
      for (int j = 1; j <= ulength; j++) {
        row.push_back(up[i][j]);
      }

      /* free memory of i-th row in up array */
      free(up[i]);

      up_vec.push_back(row);
    }
    free(up);

    return up_vec;
  }


#include <sstream>

SWIGINTERN SOLUTION *SOLUTION_get(SOLUTION *self,int i){
           return self+i;
        }
SWIGINTERN int SOLUTION_size(SOLUTION *self){
           SOLUTION *s;
           for (s=self; s->structure; s++);
           return (int)(s-self);
        }
SWIGINTERN void delete_SOLUTION(SOLUTION *self){
           SOLUTION *s;
           for (s=self; s->structure; s++) free(s->structure);
           free(self);
        }

typedef struct {
    float energy;
    std::string structure;
} subopt_solution;


SWIGINTERN std::string subopt_solution___str__(subopt_solution *self){
    std::ostringstream out;
    out << "{ structure: \"" << self->structure << "\"";
    out << ", energy: " << self->energy;
    out << " }";

    return std::string(out.str());
  }

  namespace swig {
    template <>  struct traits< subopt_solution > {
      typedef pointer_category category;
      static const char* type_name() { return"subopt_solution"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< subopt_solution, std::allocator< subopt_solution > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "subopt_solution" "," "std::allocator< subopt_solution >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_subopt_solution_Sg__iterator(std::vector< subopt_solution > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_subopt_solution_Sg____nonzero__(std::vector< subopt_solution > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_subopt_solution_Sg____bool__(std::vector< subopt_solution > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< subopt_solution >::size_type std_vector_Sl_subopt_solution_Sg____len__(std::vector< subopt_solution > const *self){
      return self->size();
    }
SWIGINTERN std::vector< subopt_solution,std::allocator< subopt_solution > > *std_vector_Sl_subopt_solution_Sg____getslice__(std::vector< subopt_solution > *self,std::vector< subopt_solution >::difference_type i,std::vector< subopt_solution >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____setslice____SWIG_0(std::vector< subopt_solution > *self,std::vector< subopt_solution >::difference_type i,std::vector< subopt_solution >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< subopt_solution,std::allocator< subopt_solution > >());
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____setslice____SWIG_1(std::vector< subopt_solution > *self,std::vector< subopt_solution >::difference_type i,std::vector< subopt_solution >::difference_type j,std::vector< subopt_solution,std::allocator< subopt_solution > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____delslice__(std::vector< subopt_solution > *self,std::vector< subopt_solution >::difference_type i,std::vector< subopt_solution >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____delitem____SWIG_0(std::vector< subopt_solution > *self,std::vector< subopt_solution >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< subopt_solution,std::allocator< subopt_solution > > *std_vector_Sl_subopt_solution_Sg____getitem____SWIG_0(std::vector< subopt_solution > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type id = i;
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____setitem____SWIG_0(std::vector< subopt_solution > *self,SWIGPY_SLICEOBJECT *slice,std::vector< subopt_solution,std::allocator< subopt_solution > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type id = i;
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____setitem____SWIG_1(std::vector< subopt_solution > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type id = i;
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____delitem____SWIG_1(std::vector< subopt_solution > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type id = i;
      std::vector< subopt_solution,std::allocator< subopt_solution > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< subopt_solution >::value_type const &std_vector_Sl_subopt_solution_Sg____getitem____SWIG_1(std::vector< subopt_solution > const *self,std::vector< subopt_solution >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg____setitem____SWIG_2(std::vector< subopt_solution > *self,std::vector< subopt_solution >::difference_type i,std::vector< subopt_solution >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< subopt_solution >::value_type std_vector_Sl_subopt_solution_Sg__pop(std::vector< subopt_solution > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< subopt_solution,std::allocator< subopt_solution > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg__append(std::vector< subopt_solution > *self,std::vector< subopt_solution >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< subopt_solution >::iterator std_vector_Sl_subopt_solution_Sg__erase__SWIG_0(std::vector< subopt_solution > *self,std::vector< subopt_solution >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< subopt_solution >::iterator std_vector_Sl_subopt_solution_Sg__erase__SWIG_1(std::vector< subopt_solution > *self,std::vector< subopt_solution >::iterator first,std::vector< subopt_solution >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< subopt_solution >::iterator std_vector_Sl_subopt_solution_Sg__insert__SWIG_0(std::vector< subopt_solution > *self,std::vector< subopt_solution >::iterator pos,std::vector< subopt_solution >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_subopt_solution_Sg__insert__SWIG_1(std::vector< subopt_solution > *self,std::vector< subopt_solution >::iterator pos,std::vector< subopt_solution >::size_type n,std::vector< subopt_solution >::value_type const &x){ self->insert(pos, n, x); }


  SOLUTION *
  my_subopt(char  *seq,
            char  *constraint,
            int   delta,
            FILE  *nullfile = NULL)
  {
    return subopt(seq, constraint, delta, nullfile);
  }

  std::vector<subopt_solution>
  my_subopt(char  *seq,
            int   delta,
            FILE  *nullfile = NULL)
  {
    std::vector<subopt_solution> ret;
    SOLUTION *sol = subopt(seq, NULL, delta, nullfile);
    if (sol)
      for(int i = 0; sol[i].structure != NULL; i++){
        subopt_solution a{ sol[i].energy, sol[i].structure};
        ret.push_back(a);
        free(sol[i].structure);
      }

    free(sol);
    /* The memory occupied by the individual structures will be free'd automatically
       by swig, when the vector is destroyed
    */
    return ret;
  }



  char *
  my_inverse_fold(char        *start,
                  const char  *target,
                  float *cost)
  {
    char *seq;
    int n;
    n = strlen(target);
    seq = vrna_random_string(n, symbolset);
    if (start)
      strncpy(seq, start, n);
    *cost = inverse_fold(seq, target);
    if (start)
      /* for backward compatibility modify start */
      strncpy(start, seq, n);
    return(seq);
  }


  char *
  my_inverse_pf_fold( char        *start,
                      const char  *target,
                      float       *cost)
  {
    char *seq;
    int n;
    n = strlen(target);
    seq = vrna_random_string(n, symbolset);
    if (start)
      strncpy(seq, start, n);
    *cost = inverse_pf_fold(seq, target);
    if (start)
      /* for backward compatibility modify start */
      strncpy(start, seq, n);
    return(seq);
  }


void *deref_any(void **ptr, int index) {
   /* dereference arbitray pointer */
   return (void *) ptr[index];
}


char *get_aligned_line(int i) {
  i = i % 2;
  return aligned_line[i];
}



  std::vector<double>
  my_file_SHAPE_read( std::string file_name,
                      int         length,
                      double      default_value,
                      std::string *shape_sequence,
                      int         *status)
  {
    std::vector<double> values (length+1, -999);
    char *seq = (char *)vrna_alloc(sizeof(char) * (length + 1));

    *status = vrna_file_SHAPE_read(file_name.c_str(), length, default_value, seq, (double *)&values[0]);

    *shape_sequence = std::string(seq);

    free(seq);
    return values;
  }



  int
  my_file_fasta_read( std::string               *id,
                      std::string               *sequence,
                      std::vector<std::string>  *rest,
                      FILE                      *file,
                      unsigned int              options = 0)
  {
    char  *c_seq, *c_id, **c_rest, **ptr;
    int   ret;

    ret = vrna_file_fasta_read_record(&c_id, &c_seq, &c_rest, file, options);

    if (ret != -1) {
      rest->clear();
      rest->reserve(ret);

      *id        = (c_id) ? c_id : "";
      *sequence  = (c_seq) ? c_seq : "";

      if ((c_rest) &&
          (*c_rest))
        for (ptr = c_rest; *ptr; ptr++) {
          std::string line(*ptr);
          rest->push_back(line);
          free(*ptr);
        }

      free(c_id);
      free(c_seq);
      free(c_rest);
    }

    return ret;
  }



  int
  my_file_RNAstrand_db_read_record(FILE         *fp,
                                   std::string  *name,
                                   std::string  *sequence,
                                   std::string  *structure,
                                   std::string  *source,
                                   std::string  *fname,
                                   std::string  *id,
                                   unsigned int options = 0)
  {
    char *c_name, *c_sequence, *c_structure, *c_source, *c_fname, *c_id;

    int r = vrna_file_RNAstrand_db_read_record(fp,
                                               &c_name,
                                               &c_sequence,
                                               &c_structure,
                                               &c_source,
                                               &c_fname,
                                               &c_id,
                                               options);

    if (r) {
      *name      = (c_name) ? c_name : "";
      *sequence  = (c_sequence) ? c_sequence : "";
      *structure = (c_structure) ? c_structure : "";
      *source    = (c_source) ? c_source : "";
      *fname     = (c_fname) ? c_fname : "";
      *id        = (c_id) ? c_id : "";

      free(c_name);
      free(c_sequence);
      free(c_structure);
      free(c_source);
      free(c_fname);
      free(c_id);
    }

    return r;
  }



  int
  my_file_connect_read_record(FILE         *fp,
                              std::string  *id,
                              std::string  *sequence,
                              std::string  *structure,
                              std::string  *remainder,
                              unsigned int options = 0)
  {
    char *c_sequence, *c_structure, *c_id, *c_remainder;

    c_remainder = (remainder->size() > 0) ? strdup(remainder->c_str()) : NULL;

    int r = vrna_file_connect_read_record(fp,
                                          &c_id,
                                          &c_sequence,
                                          &c_structure,
                                          &c_remainder,
                                          options);

    if (r) {
      *id        = (c_id) ? c_id : "";
      *sequence  = (c_sequence) ? c_sequence : "";
      *structure = (c_structure) ? c_structure : "";
      *remainder = (c_remainder) ? std::string(c_remainder) : "";

      free(c_id);
      free(c_sequence);
      free(c_structure);
      free(c_remainder);
    }

    return r;
  }




  unsigned int
  my_file_msa_detect_format(std::string   filename,
                            unsigned int  options = VRNA_FILE_FORMAT_MSA_DEFAULT)
  {
    return vrna_file_msa_detect_format(filename.c_str(), options);
  }


  int
  my_file_msa_read( std::string               filename,
                    std::vector<std::string>  *names,
                    std::vector<std::string>  *alignment,
                    std::string               *id,
                    std::string               *structure,
                    unsigned int              options = VRNA_FILE_FORMAT_MSA_STOCKHOLM)
  {
    char **c_names, **c_aln, *c_id, *c_structure;

    int ret = vrna_file_msa_read(filename.c_str(), &c_names, &c_aln, &c_id, &c_structure, options);

    if (ret != -1) {
      names->clear();
      alignment->clear();

      names->reserve(ret);
      alignment->reserve(ret);

      for (int i = 0; i < ret; i++) {
        std::string id(c_names[i]);
        std::string seq(c_aln[i]);
        names->push_back(id);
        alignment->push_back(seq);
        free(c_names[i]);
        free(c_aln[i]);
      }
      *id        = (c_id) ? c_id : "";
      *structure = (c_structure) ? c_structure : "";

      free(c_names);
      free(c_aln);
      free(c_id);
      free(c_structure);
    }

    return ret;
  }


  int
  my_file_msa_read_record(FILE                      *filehandle,
                          std::vector<std::string>  *names,
                          std::vector<std::string>  *alignment,
                          std::string               *id,
                          std::string               *structure,
                          unsigned int              options = VRNA_FILE_FORMAT_MSA_STOCKHOLM)
  {
    char **c_names, **c_aln, *c_id, *c_structure;

    int ret = vrna_file_msa_read_record(filehandle, &c_names, &c_aln, &c_id, &c_structure, options);

    if (ret != -1) {
      names->clear();
      alignment->clear();

      names->reserve(ret);
      alignment->reserve(ret);

      for (int i = 0; i < ret; i++) {
        std::string id(c_names[i]);
        std::string seq(c_aln[i]);
        names->push_back(id);
        alignment->push_back(seq);
        free(c_names[i]);
        free(c_aln[i]);
      }
      *id        = (c_id) ? c_id : "";
      *structure = (c_structure) ? c_structure : "";

      free(c_names);
      free(c_aln);
      free(c_id);
      free(c_structure);
    }

    return ret;
  }


  int
  my_file_msa_write(std::string               filename,
                    std::vector<std::string>  names,
                    std::vector<std::string>  alignment,
                    std::string               id = "",
                    std::string               structure = "",
                    std::string               source = "",
                    unsigned int              options = VRNA_FILE_FORMAT_MSA_STOCKHOLM | VRNA_FILE_FORMAT_MSA_APPEND)
  {
    std::vector<const char*>  v_names;
    std::vector<const char*>  v_aln;

    transform(names.begin(), names.end(), back_inserter(v_names), convert_vecstring2veccharcp);
    v_names.push_back(NULL); /* mark end of sequences */
    transform(alignment.begin(), alignment.end(), back_inserter(v_aln), convert_vecstring2veccharcp);
    v_aln.push_back(NULL); /* mark end of sequences */

    return vrna_file_msa_write(filename.c_str(),
                              (const char **)&v_names[0],
                              (const char **)&v_aln[0],
                              (id != "") ? id.c_str() : NULL,
                              (structure != "") ? structure.c_str() : NULL,
                              (source != "") ? source.c_str() : NULL,
                              options);
  }



#include <vector>

  std::vector<int>
  my_seq_encode(std::string sequence,
                vrna_md_t   *md_p = NULL)
  {
    short             *s;
    int               n;
    std::vector<int>  encoding;
    vrna_md_t         md;

    if (!md_p) {
      vrna_md_set_default(&md);
      md_p = &md;
    }

    n = sequence.length();
    s = vrna_seq_encode(sequence.c_str(),
                        md_p);
  
    encoding.push_back(n);
    for (int i = 1; i <= n; i++)
      encoding.push_back(s[i]);

    free(s);

    return encoding;
  }


SWIGINTERN vrna_command_s *new_vrna_command_s(){
    vrna_command_s *c = NULL;
    return c;
  }
SWIGINTERN void delete_vrna_command_s(vrna_command_s *self){
    vrna_commands_free(self);
  }

  struct vrna_command_s *
  my_file_commands_read(std::string   filename,
                        unsigned int  options = VRNA_CMD_PARSE_DEFAULTS)
  {
    int i;

    return vrna_file_commands_read(filename.c_str(),
                                   options);
  }


  std::vector<std::vector<int> >
  my_enumerate_necklaces( std::vector<unsigned int> entity_counts)
  {
    std::vector<std::vector<int> > permutations;
    /* add a 0 entry, just in case it has been forgotten */
    entity_counts.push_back(0);
    unsigned int **result = vrna_enumerate_necklaces((const unsigned int *)&entity_counts[0]);
    if(result){
      /* get line length */
      unsigned int n = 0;
      for(std::vector<unsigned int>::iterator it = entity_counts.begin(); it != entity_counts.end(); ++it)
        n += *it;

      for(int i = 0; result[i]; i++){
        std::vector<int> line;
        for(unsigned int j = 1; j <= n; j++)
          line.push_back((int)result[i][j]);
        free(result[i]);
        permutations.push_back(line);
      }
      free(result);
    }
    return permutations;
  }


  std::vector<unsigned int>
  my_rotational_symmetry(std::string string)
  {
    std::vector<unsigned int> positions;
    unsigned int i, r, *pos;
    
    r = vrna_rotational_symmetry_pos(string.c_str(), &pos);

    if (r)
      for (i = 0; i < r; i++)
        positions.push_back(pos[i]);

    free(pos);

    return positions;
  }


  std::vector<unsigned int>
  my_rotational_symmetry(std::vector<unsigned int> string)
  {
    std::vector<unsigned int> positions;
    unsigned int i, r, *pos;
    
    r = vrna_rotational_symmetry_pos_num((unsigned int*)&string[0], string.size(), &pos);

    if (r)
      for (i = 0; i < r; i++)
        positions.push_back(pos[i]);

    free(pos);

    return positions;
  }



  std::vector<unsigned int>
  boustrophedon(unsigned int start,
                unsigned int end)
  {
    std::vector<unsigned int> sequence;
    unsigned int *result = vrna_boustrophedon(start, end);

    if (result) {
      for (size_t i = 0; i <= result[0]; i++)
        sequence.push_back(result[i]);

      free(result);
    }

    return sequence;
  }

  unsigned int
  boustrophedon(unsigned int start,
                unsigned int end,
                unsigned int pos)
  {
    return vrna_boustrophedon_pos((size_t)start,
                                  (size_t)end,
                                  (size_t)pos);
  }


  std::vector<std::vector<unsigned int> >
  n_multichoose_k(unsigned int n,
                  unsigned int k)
  {
    unsigned int **result;
    std::vector<std::vector<unsigned int> > r;
    result = vrna_n_multichoose_k(n, k);

    for (size_t j = 0; result[j] != NULL; j++) {
      std::vector<unsigned int> e;
      for (size_t i = 0; i < k; i++)
        e.push_back(result[j][i]);

      r.push_back(e);
      free(result[j]);
    }

    free(result);

    return r;
  }




typedef struct {
  int i;
  int j;
  double energy;
  std::string structure;
} duplex_list_t;



  namespace swig {
    template <>  struct traits< duplex_list_t > {
      typedef pointer_category category;
      static const char* type_name() { return"duplex_list_t"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< duplex_list_t, std::allocator< duplex_list_t > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "duplex_list_t" "," "std::allocator< duplex_list_t >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_duplex_list_t_Sg__iterator(std::vector< duplex_list_t > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_duplex_list_t_Sg____nonzero__(std::vector< duplex_list_t > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_duplex_list_t_Sg____bool__(std::vector< duplex_list_t > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< duplex_list_t >::size_type std_vector_Sl_duplex_list_t_Sg____len__(std::vector< duplex_list_t > const *self){
      return self->size();
    }
SWIGINTERN std::vector< duplex_list_t,std::allocator< duplex_list_t > > *std_vector_Sl_duplex_list_t_Sg____getslice__(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::difference_type i,std::vector< duplex_list_t >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____setslice____SWIG_0(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::difference_type i,std::vector< duplex_list_t >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< duplex_list_t,std::allocator< duplex_list_t > >());
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____setslice____SWIG_1(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::difference_type i,std::vector< duplex_list_t >::difference_type j,std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____delslice__(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::difference_type i,std::vector< duplex_list_t >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____delitem____SWIG_0(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< duplex_list_t,std::allocator< duplex_list_t > > *std_vector_Sl_duplex_list_t_Sg____getitem____SWIG_0(std::vector< duplex_list_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type id = i;
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____setitem____SWIG_0(std::vector< duplex_list_t > *self,SWIGPY_SLICEOBJECT *slice,std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type id = i;
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____setitem____SWIG_1(std::vector< duplex_list_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type id = i;
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____delitem____SWIG_1(std::vector< duplex_list_t > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type id = i;
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< duplex_list_t >::value_type const &std_vector_Sl_duplex_list_t_Sg____getitem____SWIG_1(std::vector< duplex_list_t > const *self,std::vector< duplex_list_t >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg____setitem____SWIG_2(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::difference_type i,std::vector< duplex_list_t >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< duplex_list_t >::value_type std_vector_Sl_duplex_list_t_Sg__pop(std::vector< duplex_list_t > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< duplex_list_t,std::allocator< duplex_list_t > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg__append(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< duplex_list_t >::iterator std_vector_Sl_duplex_list_t_Sg__erase__SWIG_0(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< duplex_list_t >::iterator std_vector_Sl_duplex_list_t_Sg__erase__SWIG_1(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::iterator first,std::vector< duplex_list_t >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< duplex_list_t >::iterator std_vector_Sl_duplex_list_t_Sg__insert__SWIG_0(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::iterator pos,std::vector< duplex_list_t >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_duplex_list_t_Sg__insert__SWIG_1(std::vector< duplex_list_t > *self,std::vector< duplex_list_t >::iterator pos,std::vector< duplex_list_t >::size_type n,std::vector< duplex_list_t >::value_type const &x){ self->insert(pos, n, x); }


  duplex_list_t
  my_duplexfold(std::string s1,
                std::string s2)
  {
    duplexT r = duplexfold(s1.c_str(), s2.c_str());
    duplex_list_t res{r.i, r.j, r.energy, r.structure};
    free(r.structure);
    return res;
  }

  std::vector<duplex_list_t>
  my_duplex_subopt( std::string s1,
                    std::string s2,
                    int         delta,
                    int         w)
  {
    std::vector<duplex_list_t> ret;
    duplexT *list, *ptr;
    list = duplex_subopt(s1.c_str(), s2.c_str(), delta, w);
 
    for (ptr = list; ptr->structure != NULL; ptr++) {
      duplex_list_t a{ ptr->i, ptr->j, ptr->energy, ptr->structure};
      ret.push_back(a);
      free(ptr->structure);
    }
    free(list);

    return ret;
  }

  duplex_list_t
  my_aliduplexfold(std::vector<std::string> alignment1,
                   std::vector<std::string> alignment2)
  {
    std::vector<const char*> aln_vec1;
    std::transform(alignment1.begin(), alignment1.end(), std::back_inserter(aln_vec1), convert_vecstring2veccharcp);
    aln_vec1.push_back(NULL); /* mark end of sequences */
    std::vector<const char*> aln_vec2;
    std::transform(alignment2.begin(), alignment2.end(), std::back_inserter(aln_vec2), convert_vecstring2veccharcp);
    aln_vec2.push_back(NULL); /* mark end of sequences */

    duplexT r = aliduplexfold((const char **)&aln_vec1[0], (const char **)&aln_vec2[0]);
    duplex_list_t res{r.i, r.j, r.energy, r.structure};
    free(r.structure);
    return res;

  }

  std::vector<duplex_list_t>
  my_aliduplex_subopt(std::vector<std::string> alignment1,
                      std::vector<std::string> alignment2,
                      int                      delta,
                      int                      w)
  {
    std::vector<duplex_list_t> ret;
    duplexT *list, *ptr;
    std::vector<const char*> aln_vec1;
    std::transform(alignment1.begin(), alignment1.end(), std::back_inserter(aln_vec1), convert_vecstring2veccharcp);
    aln_vec1.push_back(NULL); /* mark end of sequences */
    std::vector<const char*> aln_vec2;
    std::transform(alignment2.begin(), alignment2.end(), std::back_inserter(aln_vec2), convert_vecstring2veccharcp);
    aln_vec2.push_back(NULL); /* mark end of sequences */

    list = aliduplex_subopt((const char **)&aln_vec1[0], (const char **)&aln_vec2[0], delta, w);
    for (ptr = list; ptr->structure != NULL; ptr++) {
      duplex_list_t a{ ptr->i, ptr->j, ptr->energy, ptr->structure};
      ret.push_back(a);
      free(ptr->structure);
    }
    free(list);

    return ret;
  }


 void
 my_get_concentrations(double FcAB,
                       double FcAA,
                       double FcBB,
                       double FEA,
                       double FEB,
                       double Ac_start,
                       double Bc_start,
                       double *AB,
                       double *AA,
                       double *BB,
                       double *A,
                       double *B)
  {
    vrna_dimer_conc_t *temp;
    double *concis;
    concis = (double *)calloc(4,sizeof(double));
    concis[0]=Ac_start;
    concis[1]=Bc_start;
    concis[2]=0;
    temp=get_concentrations(FcAB,FcAA,FcBB,FEA,FEB,concis);
    *AB=temp->ABc;
    *AA=temp->AAc;
    *BB=temp->BBc;
    *A=temp->Ac;
    *B=temp->Bc;
    free(concis);
    free(temp);
    return;
  }



  std::vector<double>
  my_equilibrium_constants(std::vector<double>                      dG_complexes,
                           std::vector<double>                      dG_strands,
                           std::vector<std::vector<unsigned int> >  A,
                           double                                   kT,
                           size_t                                   strands = 0,
                           size_t                                   complexes = 0)
  {
    double              *constants = NULL;
    unsigned int        **assoc_mx;
    std::vector<double> constants_vector;

    if (strands == 0)
      strands = (size_t)dG_strands.size();

    if (complexes == 0)
      complexes = (size_t)dG_complexes.size();

    assoc_mx = (unsigned int **)vrna_alloc(sizeof(unsigned int *) * A.size());
    for (size_t k = 0; k < A.size(); k++) {
      assoc_mx[k] = (unsigned int *)vrna_alloc(sizeof(unsigned int) * A[k].size());
      memcpy(assoc_mx[k], A[k].data(), sizeof(unsigned int) * A[k].size());
    }

    constants = vrna_equilibrium_constants(&(dG_complexes[0]),
                                           &(dG_strands[0]),
                                           (const unsigned int **)assoc_mx,
                                           kT,
                                           strands,
                                           complexes);

    /* reformat output array to actual vector */
    for (size_t k = 0; k < complexes; k++)
      constants_vector.push_back(constants[k]);

    for (size_t k = 0; k < A.size(); k++)
      free(assoc_mx[k]);

    free(assoc_mx);

    free(constants);

    return constants_vector;
  }



  std::vector<double>
  my_equilibrium_conc(std::vector<double> eq_constants,
                      std::vector<double> concentration_strands,
                      std::vector<std::vector<unsigned int> >  A,
                      size_t                                   strands = 0,
                      size_t                                   complexes = 0)
  {
    double              *conc = NULL;
    std::vector<double> concentrations;
    unsigned int        **assoc_mx;

    if (strands == 0)
      strands = (size_t)concentration_strands.size();

    if (complexes == 0)
      complexes = (size_t)eq_constants.size();

    assoc_mx = (unsigned int **)vrna_alloc(sizeof(unsigned int *) * A.size());
    for (size_t k = 0; k < A.size(); k++) {
      assoc_mx[k] = (unsigned int *)vrna_alloc(sizeof(unsigned int) * A[k].size());
      memcpy(assoc_mx[k], A[k].data(), sizeof(unsigned int) * A[k].size());
    }

    conc = vrna_equilibrium_conc(&(eq_constants[0]),
                                 &(concentration_strands[0]),
                                 (const unsigned int **)assoc_mx,
                                 strands,
                                 complexes);

    /* reformat output array to actual vector */
    for (size_t k = 0; k < complexes; k++)
      concentrations.push_back(conc[k]);

    /* append equilibrium concentrations for monomers here as well */
    for (size_t k = 0; k < strands; k++)
      concentrations.push_back(concentration_strands[k]);

    for (size_t k = 0; k < A.size(); k++)
      free(assoc_mx[k]);

    free(assoc_mx);

    free(conc);

    return concentrations;
  } 
                          



#include <sstream>

SWIGINTERN vrna_move_t *new_vrna_move_t(int pos_5=0,int pos_3=0){
    vrna_move_t *m = (vrna_move_t *)vrna_alloc(sizeof(vrna_move_t));
    *m = vrna_move_init(pos_5, pos_3);
    return m;
  }
SWIGINTERN void delete_vrna_move_t(vrna_move_t *self){
    vrna_move_list_free(self->next);
    free(self);
  }
SWIGINTERN int vrna_move_t_is_removal(vrna_move_t *self){
    return vrna_move_is_removal((const vrna_move_t *)self);
  }
SWIGINTERN int vrna_move_t_is_insertion(vrna_move_t *self){
    return vrna_move_is_insertion((const vrna_move_t *)self);
  }
SWIGINTERN int vrna_move_t_is_shift(vrna_move_t *self){
    return vrna_move_is_shift((const vrna_move_t *)self);
  }
SWIGINTERN int vrna_move_t_compare(vrna_move_t *self,vrna_move_t const *b,std::vector< int,std::allocator< int > > const pt=std::vector< int >()){
    int result;
    std::vector<short> vs;
    transform(pt.begin(), pt.end(), back_inserter(vs), convert_vecint2vecshort);

    result =  vrna_move_compare(self,
                                b,
                                (const short *)&vs[0]);

    return result;
  }
SWIGINTERN std::string vrna_move_t___str__(vrna_move_t *self){
    std::ostringstream out;
    out << "{ pos_5: " << self->pos_5;
    out << ", pos_3: " << self->pos_3;
    out << " }";

    return std::string(out.str());
  }

#include <sstream>

SWIGINTERN vrna_path_t *new_vrna_path_t(double en,std::string s="",vrna_move_t *move=NULL,unsigned int type=VRNA_PATH_TYPE_DOT_BRACKET){
    vrna_path_t *step = (vrna_path_t *)vrna_alloc(sizeof(vrna_path_t));

    step->type  = type;
    step->en    = en;

    if ((s == "") && (move))
      type = VRNA_PATH_TYPE_MOVES;

    switch (type) {
      case VRNA_PATH_TYPE_DOT_BRACKET:
        if (s != "") {
          step->s = (char *)vrna_alloc(sizeof(char) * (s.length() + 1));
          memcpy(step->s, s.c_str(), sizeof(char) * s.length());
        } else {
          step->s = NULL;
        }
        break;

      case VRNA_PATH_TYPE_MOVES:
        if (move) {
          step->move.pos_5 = move->pos_5;
          step->move.pos_3 = move->pos_3;
        } else {
          step->move.pos_5 = 0;
          step->move.pos_3 = 0;
        }
        break;

      default:
        break;
    }


    return step;
  }
SWIGINTERN void delete_vrna_path_t(vrna_path_t *self){
    free(self->s);
    free(self);
  }
SWIGINTERN std::string vrna_path_t___str__(vrna_path_t *self){
    std::ostringstream out;
    out << "{ type: " << self->type;
    switch(self->type) {
      case VRNA_PATH_TYPE_MOVES:
        out << ", s: None";
        break;

      case VRNA_PATH_TYPE_DOT_BRACKET:
        if (self->s)
          out << ", s: \"" << self->s << "\"";
        else
          out << ", s: None";
        break;

      default:
        out << ", s: None";
        break;
    }

    out << ", en: " << self->en;

    if (self->type == VRNA_PATH_TYPE_MOVES)
      out << ", move: { pos_5: " << self->move.pos_5 << ", pos_3: " << self->move.pos_3 << "}";
    else
      out << ", move: None";

    out << " }";

    return std::string(out.str());
  }
SWIGINTERN vrna_path_options_s *new_vrna_path_options_s(){
    return NULL;
  }
SWIGINTERN void delete_vrna_path_options_s(vrna_path_options_s *self){
    vrna_path_options_free(self);
  }

  struct vrna_path_options_s *
  my_path_options_findpath(int          width = 10,
                           unsigned int type  = VRNA_PATH_TYPE_DOT_BRACKET)
  {
    return vrna_path_options_findpath(width, type);
  }


  std::vector<vrna_path_t>
  my_get_path(std::string seq,
              std::string s1,
              std::string s2,
              int         maxkeep)
  {
    std::vector<vrna_path_t>  v; /* fill vector with returned vrna_path_t*/
    vrna_path_t *path_t, *ptr;

    path_t = ptr = get_path(seq.c_str(), s1.c_str(), s2.c_str(), maxkeep);

    while (ptr->s != NULL)
    {
        vrna_path_t p;

        p.type  = VRNA_PATH_TYPE_DOT_BRACKET;
        p.en    = ptr->en;
        p.s     = ptr->s;

        v.push_back(p);
        ptr++;
        
    }
    free(path_t);
    return v;
  }



extern "C" {
  typedef struct {
    float temperature;    /**< @brief   The temperature in &deg;C */
    float heat_capacity;  /**< @brief   The specific heat at this temperature in Kcal/(Mol * K) */
  } heat_capacity_result;
}


SWIGINTERN std::string heat_capacity_result___str__(heat_capacity_result *self){
    std::ostringstream out;
    out << "{ temperature: \"" << self->temperature << "\"";
    out << ", heat_capacity: " << self->heat_capacity;
    out << " }";

    return std::string(out.str());
  }

  namespace swig {
    template <>  struct traits< heat_capacity_result > {
      typedef pointer_category category;
      static const char* type_name() { return"heat_capacity_result"; }
    };
  }


      namespace swig {
	template <>  struct traits<std::vector< heat_capacity_result, std::allocator< heat_capacity_result > > > {
	  typedef pointer_category category;
	  static const char* type_name() {
	    return "std::vector<" "heat_capacity_result" "," "std::allocator< heat_capacity_result >" " >";
	  }
	};
      }
    
SWIGINTERN swig::SwigPyIterator *std_vector_Sl_heat_capacity_result_Sg__iterator(std::vector< heat_capacity_result > *self,PyObject **PYTHON_SELF){
      return swig::make_output_iterator(self->begin(), self->begin(), self->end(), *PYTHON_SELF);
    }
SWIGINTERN bool std_vector_Sl_heat_capacity_result_Sg____nonzero__(std::vector< heat_capacity_result > const *self){
      return !(self->empty());
    }
SWIGINTERN bool std_vector_Sl_heat_capacity_result_Sg____bool__(std::vector< heat_capacity_result > const *self){
      return !(self->empty());
    }
SWIGINTERN std::vector< heat_capacity_result >::size_type std_vector_Sl_heat_capacity_result_Sg____len__(std::vector< heat_capacity_result > const *self){
      return self->size();
    }
SWIGINTERN std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *std_vector_Sl_heat_capacity_result_Sg____getslice__(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::difference_type i,std::vector< heat_capacity_result >::difference_type j){
      return swig::getslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____setslice____SWIG_0(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::difference_type i,std::vector< heat_capacity_result >::difference_type j){
      swig::setslice(self, i, j, 1, std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >());
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____setslice____SWIG_1(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::difference_type i,std::vector< heat_capacity_result >::difference_type j,std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &v){
      swig::setslice(self, i, j, 1, v);
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____delslice__(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::difference_type i,std::vector< heat_capacity_result >::difference_type j){
      swig::delslice(self, i, j, 1);
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____delitem____SWIG_0(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::difference_type i){
      swig::erase(self, swig::getpos(self, i));
    }
SWIGINTERN std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *std_vector_Sl_heat_capacity_result_Sg____getitem____SWIG_0(std::vector< heat_capacity_result > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return NULL;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type id = i;
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type jd = j;
      return swig::getslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____setitem____SWIG_0(std::vector< heat_capacity_result > *self,SWIGPY_SLICEOBJECT *slice,std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &v){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type id = i;
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type jd = j;
      swig::setslice(self, id, jd, step, v);
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____setitem____SWIG_1(std::vector< heat_capacity_result > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type id = i;
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____delitem____SWIG_1(std::vector< heat_capacity_result > *self,SWIGPY_SLICEOBJECT *slice){
      Py_ssize_t i, j, step;
      if( !PySlice_Check(slice) ) {
        SWIG_Error(SWIG_TypeError, "Slice object expected.");
        return;
      }
      PySlice_GetIndices(slice, (Py_ssize_t)self->size(), &i, &j, &step);
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type id = i;
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::difference_type jd = j;
      swig::delslice(self, id, jd, step);
    }
SWIGINTERN std::vector< heat_capacity_result >::value_type const &std_vector_Sl_heat_capacity_result_Sg____getitem____SWIG_1(std::vector< heat_capacity_result > const *self,std::vector< heat_capacity_result >::difference_type i){
      return *(swig::cgetpos(self, i));
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg____setitem____SWIG_2(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::difference_type i,std::vector< heat_capacity_result >::value_type const &x){
      *(swig::getpos(self,i)) = x;
    }
SWIGINTERN std::vector< heat_capacity_result >::value_type std_vector_Sl_heat_capacity_result_Sg__pop(std::vector< heat_capacity_result > *self){
      if (self->size() == 0)
	throw std::out_of_range("pop from empty container");
      std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >::value_type x = self->back();
      self->pop_back();
      return x;
    }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg__append(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::value_type const &x){
      self->push_back(x);
    }
SWIGINTERN std::vector< heat_capacity_result >::iterator std_vector_Sl_heat_capacity_result_Sg__erase__SWIG_0(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::iterator pos){ return self->erase(pos); }
SWIGINTERN std::vector< heat_capacity_result >::iterator std_vector_Sl_heat_capacity_result_Sg__erase__SWIG_1(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::iterator first,std::vector< heat_capacity_result >::iterator last){ return self->erase(first, last); }
SWIGINTERN std::vector< heat_capacity_result >::iterator std_vector_Sl_heat_capacity_result_Sg__insert__SWIG_0(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::iterator pos,std::vector< heat_capacity_result >::value_type const &x){ return self->insert(pos, x); }
SWIGINTERN void std_vector_Sl_heat_capacity_result_Sg__insert__SWIG_1(std::vector< heat_capacity_result > *self,std::vector< heat_capacity_result >::iterator pos,std::vector< heat_capacity_result >::size_type n,std::vector< heat_capacity_result >::value_type const &x){ self->insert(pos, n, x); }

  std::vector<heat_capacity_result>
  my_heat_capacity(std::string   sequence,
                   float         T_min        = 0.,
                   float         T_max        = 100.,
                   float         T_increment  = 1.,
                   unsigned int  mpoints      = 2U)
  {
    vrna_heat_capacity_t              *result_c;
    std::vector<heat_capacity_result> result;

    result_c = vrna_heat_capacity_simple(sequence.c_str(), T_min, T_max, T_increment, mpoints);

    if (result_c) {
      for (size_t i = 0; result_c[i].temperature >= T_min; i++) {
        heat_capacity_result r;
        r.temperature = result_c[i].temperature;
        r.heat_capacity = result_c[i].heat_capacity;
        result.push_back(r);
      }
    }

    free(result_c);

    return result;
  }



#include <stdexcept>

typedef struct {
  PyObject  *cb;
  PyObject  *data;
  PyObject  *delete_data;
} pycallback_t;

static void
py_wrap_fc_status_callback(vrna_fold_compound_t  *fc,
                           unsigned char status,
                           void          *data);

static void
delete_pydata(pycallback_t *cb)
{
  if(cb->data != Py_None){
    if(cb->delete_data != Py_None){
      /* call user-defined data destructor */
      PyObject *func, *arglist, *result, *err;
      func = cb->delete_data;
      arglist = Py_BuildValue("O", cb->data);
      result  = PyObject_CallObject(func, arglist);

      /* BEGIN recognizing errors in callback execution */
      if (result == NULL) {
        if ((err = PyErr_Occurred())) {
          /* print error message */
          PyErr_Print();
          /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
          if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
            throw std::runtime_error( "Fold compound delete_data() callback must take exactly 1 argument" );
          } else {
            throw std::runtime_error( "Some error occurred while executing fold compound delete_data() callback" );
          }
        }
        PyErr_Clear();
      }
      /* END recognizing errors in callback execution */

      Py_DECREF(arglist);
      Py_XDECREF(result);
    }
  }

  Py_DECREF(cb->data);
  Py_DECREF(cb->delete_data);
}


static void
delete_pycallback(void * data)
{
  pycallback_t *cb = (pycallback_t *)data;
  /* first delete user data */
  delete_pydata(cb);

  /* now dispose of the callback */
  Py_DECREF(cb->cb);
  
  /* finally free pycallback */
  free(cb);
}

static void
fc_add_pycallback(vrna_fold_compound_t *vc,
                  PyObject             *PyFunc)
{

  /* try to dispose of previous callback */
  pycallback_t * cb;
  if(vc->auxdata){
    cb = (pycallback_t *)vc->auxdata;
    /* release previous callback */
    Py_XDECREF(cb->cb);
  } else {
    cb = (pycallback_t *)vrna_alloc(sizeof(pycallback_t));
    Py_INCREF(Py_None);
    cb->data = Py_None;

    Py_INCREF(Py_None);
    cb->delete_data = Py_None;
  }
  cb->cb = PyFunc;    /* remember callback */
  Py_XINCREF(PyFunc); /* Increase referenc counter */

  /* finaly bind callback wrapper to fold compound */
  vc->auxdata = (void *)cb;
  if(!vc->free_auxdata)
    vc->free_auxdata = &delete_pycallback;

  vrna_fold_compound_add_callback(vc, &py_wrap_fc_status_callback);
}

static void
fc_add_pydata(vrna_fold_compound_t *vc,
              PyObject             *data,
              PyObject             *PyFunc)
{

  pycallback_t * cb;
  /* try to dispose of previous data */
  if(vc->auxdata){
    cb = (pycallback_t *)vc->auxdata;
    delete_pydata(cb);
  } else {
    cb = (pycallback_t *)vrna_alloc(sizeof(pycallback_t));

    Py_INCREF(Py_None);
    cb->cb = Py_None;
  }
  cb->data        = data;   /* remember data */
  cb->delete_data = PyFunc; /* remember delete data function */

  /* increase reference counter */
  Py_INCREF(data);
  Py_INCREF(PyFunc);

  vc->auxdata = (void *)cb;
  if(!vc->free_auxdata)
    vc->free_auxdata = &delete_pycallback;
}

static void
py_wrap_fc_status_callback(vrna_fold_compound_t  *fc,
                           unsigned char status,
                           void          *data)
{

  PyObject *func, *arglist, *result, *err;
  pycallback_t *cb = (pycallback_t *)data;

  func = cb->cb;
  /* compose argument list */
  arglist = Py_BuildValue("(O,B,O)", fc, status, (cb->data) ? cb->data : Py_None);
  result =  PyObject_CallObject(func, arglist);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Fold compound callback must take exactly 3 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing fold compound callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_DECREF(arglist);
  Py_XDECREF(result);
  return /*void*/;
}




#include <stdexcept>

  typedef struct {
    PyObject  *cb_f;
    PyObject  *cb_bt;
    PyObject  *cb_exp_f;
    PyObject  *data;
    PyObject  *delete_data;
  } py_sc_callback_t;

  static int
  py_wrap_sc_f_callback(int           i,
                        int           j,
                        int           k,
                        int           l,
                        unsigned char d,
                        void          *data);


  static vrna_basepair_t *
  py_wrap_sc_bt_callback(int            i,
                         int            j,
                         int            k,
                         int            l,
                         unsigned char  d,
                         void           *data);


  static FLT_OR_DBL
  py_wrap_sc_exp_f_callback(int           i,
                            int           j,
                            int           k,
                            int           l,
                            unsigned char d,
                            void          *data);


  static void
  delete_py_sc_data(py_sc_callback_t *cb)
  {
    if ((cb->data != Py_None) &&
        (cb->delete_data != Py_None)) {
      PyObject *func, *arglist, *result, *err;
      func    = cb->delete_data;
      arglist = Py_BuildValue("O", cb->data);
      result  = PyObject_CallObject(func, arglist);

      /* BEGIN recognizing errors in callback execution */
      if (result == NULL) {
        if ((err = PyErr_Occurred())) {
          /* print error message */
          PyErr_Print();
          /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
          if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
            throw
            std::runtime_error(
              "Generic soft constraint delete_data() callback must take exactly 1 argument");


          else
            throw
            std::runtime_error(
              "Some error occurred while executing generic soft constraint delete_data() callback");
        }

        PyErr_Clear();
      }

      /* END recognizing errors in callback execution */

      Py_DECREF(arglist);
      Py_XDECREF(result);
    }

    Py_DECREF(cb->data);
    Py_DECREF(cb->delete_data);
  }


  static void
  delete_py_sc_callback(void *data)
  {
    py_sc_callback_t *cb = (py_sc_callback_t *)data;

    /* first delete user data */
    delete_py_sc_data(cb);

    /* now dispose of the registered callbacks */
    Py_DECREF(cb->cb_f);
    Py_DECREF(cb->cb_bt);
    Py_DECREF(cb->cb_exp_f);

    /* finally free pycallback */
    free(cb);
  }


  static py_sc_callback_t *
  reuse_or_new_cb_f(vrna_sc_t *sc)
  {
    py_sc_callback_t *cb;

    cb =
      (sc->data) ? (py_sc_callback_t *)sc->data : (py_sc_callback_t *)vrna_alloc(
        sizeof(py_sc_callback_t));

    if (cb->cb_f) {
      /* release previous callback */
      Py_DECREF(cb->cb_f);
    } else {
      /* initialize the remaining soft constraint callbacks */
      Py_INCREF(Py_None);
      cb->cb_bt = Py_None;

      Py_INCREF(Py_None);
      cb->cb_exp_f = Py_None;

      Py_INCREF(Py_None);
      cb->data = Py_None;

      Py_INCREF(Py_None);
      cb->delete_data = Py_None;
    }

    return cb;
  }


  static py_sc_callback_t *
  reuse_or_new_cb_exp_f(vrna_sc_t *sc)
  {
    py_sc_callback_t *cb;

    cb =
      (sc->data) ? (py_sc_callback_t *)sc->data : (py_sc_callback_t *)vrna_alloc(
        sizeof(py_sc_callback_t));

    if (cb->cb_exp_f) {
      /* release previous callback */
      Py_DECREF(cb->cb_exp_f);
    } else {
      /* initialize the remaining soft constraint callbacks */
      Py_INCREF(Py_None);
      cb->cb_f = Py_None;

      Py_INCREF(Py_None);
      cb->cb_bt = Py_None;

      Py_INCREF(Py_None);
      cb->data = Py_None;

      Py_INCREF(Py_None);
      cb->delete_data = Py_None;
    }

    return cb;
  }


  static py_sc_callback_t *
  reuse_or_new_cb_data(vrna_sc_t *sc)
  {
    py_sc_callback_t *cb;

    cb =
      (sc->data) ? (py_sc_callback_t *)sc->data : (py_sc_callback_t *)vrna_alloc(
        sizeof(py_sc_callback_t));

    if (cb->data) {
      /* release previous callback */
      delete_py_sc_data(cb);
    } else {
      /* initialize the remaining soft constraint callbacks */
      Py_INCREF(Py_None);
      cb->cb_f = Py_None;

      Py_INCREF(Py_None);
      cb->cb_bt = Py_None;

      Py_INCREF(Py_None);
      cb->cb_exp_f = Py_None;
    }

    return cb;
  }


  static int
  sc_add_f_pycallback(vrna_fold_compound_t  *vc,
                      PyObject              *func)
  {
    unsigned char     func_is_tuple, func_is_list;
    unsigned int      s;
    /* try to dispose of previous callback */
    py_sc_callback_t  *cb;
    PyObject          *f, *err;

    switch (vc->type) {
      case VRNA_FC_TYPE_SINGLE:
        if (!PyCallable_Check(func)) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
        } else if (vrna_sc_add_f(vc, &py_wrap_sc_f_callback)) {
          /*
           *  The above call returns 0 on any error.
           *  Otherwise it binds the wrapper function and
           *  prepares the soft constraint data structure
           *  inside vc
           */

          /* now bind the python function to the wrapper structure */
          cb = reuse_or_new_cb_f(vc->sc);

          Py_INCREF(func);  /* Increase referenc counter */
          cb->cb_f = func;  /* remember callback */

          /* finaly bind callback wrapper to fold compound */
          vc->sc->data = (void *)cb;

          /* also (re-)bind the free-callback-data function */
          vc->sc->free_data = &delete_py_sc_callback;

          return 1;
        }

        break;

      case VRNA_FC_TYPE_COMPARATIVE:
        /* first check, whether data and PyFunc are of correct type */
        func_is_tuple = PyTuple_Check(func);
        func_is_list  = PyList_Check(func);

        if (func_is_tuple || func_is_list) {
          if (!vc->scs)
            vrna_sc_init(vc);

          for (s = 0; s < vc->n_seq; s++) {
            f = (func_is_tuple) ? PyTuple_GetItem(func, s) : PyList_GetItem(func, s);

            if (f == NULL) {
              /* an error occurred */
              if ((err = PyErr_Occurred())) {
                /* print error message */
                PyErr_Print();
                /* we only treat IndexErrors differently here, as they indicate that the callback list is too short! */
                if (PyErr_GivenExceptionMatches(err, PyExc_IndexError))
                  throw
                  std::runtime_error(
                    "sc_add_f(): Comparative prediction callback list or tuple must have an entry for each sequence in the alignment");


                else
                  throw
                  std::runtime_error(
                    "sc_add_f(): Some error occurred while accessing generic soft constraint callback for sequence alignment");
              }

              PyErr_Clear();
            } else if (!PyCallable_Check(f)) {
              PyErr_SetString(PyExc_TypeError, "Need a callable object!");
            } else {
              cb = reuse_or_new_cb_f(vc->scs[s]);

              Py_INCREF(f); /* Increase reference counter */
              cb->cb_f = f; /* remember callback */

              /* finaly bind callback wrapper to fold compound */
              vc->scs[s]->data = (void *)cb;

              /* also (re-)bind the free-callback-data function */
              vc->scs[s]->free_data = &delete_py_sc_callback;

              /* finally, we bind the callback wrapper */
              vc->scs[s]->f = &py_wrap_sc_f_callback;
            }
          }

          return 1;
        } else {
          throw
          std::runtime_error(
            "sc_add_f(): Comparative prediction callbacks must be provided as list or tuple");
        }

        break;
    }

    return 0;
  }


  static int
  sc_add_exp_f_pycallback(vrna_fold_compound_t  *vc,
                          PyObject              *func)
  {
    unsigned char     func_is_tuple, func_is_list;
    unsigned int      s;
    /* try to dispose of previous callback */
    py_sc_callback_t  *cb;
    PyObject          *f, *err;

    switch (vc->type) {
      case VRNA_FC_TYPE_SINGLE:
        if (!PyCallable_Check(func)) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
        } else if (vrna_sc_add_exp_f(vc, &py_wrap_sc_exp_f_callback)) {
          /*
           *  The above call returns 0 on any error.
           *  Otherwise it binds the wrapper function and
           *  prepares the soft constraint data structure
           *  inside vc
           */

          /* now bind the python function to the wrapper structure */
          cb = reuse_or_new_cb_exp_f(vc->sc);

          Py_INCREF(func);      /* Increase referenc counter */
          cb->cb_exp_f = func;  /* remember callback */

          /* finaly bind callback wrapper to fold compound */
          vc->sc->data = (void *)cb;

          /* also (re-)bind the free-callback-data function */
          vc->sc->free_data = &delete_py_sc_callback;

          return 1;
        }

        break;

      case VRNA_FC_TYPE_COMPARATIVE:
        /* first check, whether data and PyFunc are of correct type */
        func_is_tuple = PyTuple_Check(func);
        func_is_list  = PyList_Check(func);

        if (func_is_tuple || func_is_list) {
          if (!vc->scs)
            vrna_sc_init(vc);

          for (s = 0; s < vc->n_seq; s++) {
            f = (func_is_tuple) ? PyTuple_GetItem(func, s) : PyList_GetItem(func, s);

            if (f == NULL) {
              /* an error occurred */
              if ((err = PyErr_Occurred())) {
                /* print error message */
                PyErr_Print();
                /* we only treat IndexErrors differently here, as they indicate that the callback list is too short! */
                if (PyErr_GivenExceptionMatches(err, PyExc_IndexError))
                  throw
                  std::runtime_error(
                    "sc_add_exp_f(): Comparative prediction callback list or tuple must have an entry for each sequence in the alignment");


                else
                  throw
                  std::runtime_error(
                    "sc_add_exp_f(): Some error occurred while accessing generic soft constraint callback for sequence alignment");
              }

              PyErr_Clear();
            } else if (!PyCallable_Check(f)) {
              PyErr_SetString(PyExc_TypeError, "Need a callable object!");
            } else {
              cb = reuse_or_new_cb_exp_f(vc->scs[s]);

              Py_INCREF(f);     /* Increase reference counter */
              cb->cb_exp_f = f; /* remember callback */

              /* finaly bind callback wrapper to fold compound */
              vc->scs[s]->data = (void *)cb;

              /* also (re-)bind the free-callback-data function */
              vc->scs[s]->free_data = &delete_py_sc_callback;

              /* finally, we bind the callback wrapper */
              vc->scs[s]->f = &py_wrap_sc_f_callback;
            }
          }

          return 1;
        } else {
          throw
          std::runtime_error(
            "sc_add_exp_f(): Comparative prediction callbacks must be provided as list or tuple");
        }

        break;
    }

    return 0;
  }


  static int
  sc_add_bt_pycallback(vrna_fold_compound_t *vc,
                       PyObject             *PyFunc)
  {
    /* try to dispose of previous callback */
    py_sc_callback_t *cb;

    if (vrna_sc_add_bt(vc, &py_wrap_sc_bt_callback)) {
      /*
       *  The above call returns 0 on any error.
       *  Otherwise it binds the wrapper function and
       *  prepares the soft constraint data structure
       *  inside vc
       */

      /* now bind the python function to the wrapper structure */
      if (vc->sc->data) {
        /* re-use previously bound wrapper data structure */
        cb = (py_sc_callback_t *)vc->sc->data;
        /* release previous callback */
        Py_DECREF(cb->cb_bt);
      } else {
        cb = (py_sc_callback_t *)vrna_alloc(sizeof(py_sc_callback_t));
        Py_INCREF(Py_None);
        cb->cb_f = Py_None;
        Py_INCREF(Py_None);
        cb->cb_exp_f = Py_None;
        Py_INCREF(Py_None);
        cb->data = Py_None;
        Py_INCREF(Py_None);
        cb->delete_data = Py_None;
      }

      Py_XINCREF(PyFunc); /* Increase referenc counter */
      cb->cb_bt = PyFunc; /* remember callback */

      /* finaly bind callback wrapper to fold compound */
      vc->sc->data = (void *)cb;

      /* also (re-)bind the free-callback-data function */
      vc->sc->free_data = &delete_py_sc_callback;

      return 1;
    }

    return 0;
  }


  static int
  sc_add_pydata(vrna_fold_compound_t  *vc,
                PyObject              *data,
                PyObject              *free_data_cb)
  {
    unsigned char     data_is_tuple, data_is_list, func_is_tuple, func_is_list;
    unsigned int      s;
    py_sc_callback_t  *cb;
    PyObject          *err;

    switch (vc->type) {
      case VRNA_FC_TYPE_SINGLE:
        /* create soft constraints data structure */
        if (!vc->sc)
          vrna_sc_init(vc);

        cb = reuse_or_new_cb_data(vc->sc);

        /* increase reference counters */
        Py_INCREF(data);
        cb->data = data;        /* remember data */

        if ((free_data_cb != Py_None) && (!PyCallable_Check(free_data_cb))) {
          PyErr_SetString(PyExc_TypeError, "Require a callable object for free_data_cb!");
        } else {
          Py_INCREF(free_data_cb);
          cb->delete_data = free_data_cb; /* remember delete data function */
        }

        vc->sc->data = (void *)cb;

        /* also (re-)bind the free-callback-data function */
        vc->sc->free_data = &delete_py_sc_callback;

        return 1;

      case VRNA_FC_TYPE_COMPARATIVE:
        /* first check, whether data and PyFunc are of correct type */
        data_is_tuple = PyTuple_Check(data);
        data_is_list  = PyList_Check(data);
        func_is_tuple = PyTuple_Check(free_data_cb);
        func_is_list  = PyList_Check(free_data_cb);

        if (data_is_tuple || data_is_list) {
          if (!vc->scs)
            vrna_sc_init(vc);

          /* try to dispose of previous data */
          for (s = 0; s < vc->n_seq; s++) {
            cb = reuse_or_new_cb_data(vc->scs[s]);

            /* increase reference counters */
            PyObject *d, *f;

            d = (data_is_tuple) ? PyTuple_GetItem(data, s) : PyList_GetItem(data, s);

            if (d == NULL) {
              /* an error occurred */
              if ((err = PyErr_Occurred())) {
                /* print error message */
                PyErr_Print();
                /* we only treat IndexErrors differently here, as they indicate that the callback list is too short! */
                if (PyErr_GivenExceptionMatches(err, PyExc_IndexError))
                  throw
                  std::runtime_error(
                    "sc_add_data(): Comparative prediction callback data list or tuple must have an entry for each sequence in the alignment");


                else
                  throw
                  std::runtime_error(
                    "sc_add_data(): Some error occurred while accessing generic soft constraint callback data list for sequence alignment");
              }

              PyErr_Clear();
            } else {
              Py_INCREF(d);
              cb->data = d; /* remember data */

              if (func_is_tuple || func_is_list) {
                f = (func_is_tuple) ? PyTuple_GetItem(free_data_cb, s) : PyList_GetItem(
                  free_data_cb,
                  s);
                if (f == NULL) {
                  /* an error occurred */
                  if ((err = PyErr_Occurred())) {
                    /* print error message */
                    PyErr_Print();
                    /* we only treat IndexErrors differently here, as they indicate that the callback list is too short! */
                    if (PyErr_GivenExceptionMatches(err, PyExc_IndexError))
                      throw
                      std::runtime_error(
                        "sc_add_data(): Comparative prediction callback data free() list or tuple must have an entry for each sequence in the alignment");


                    else
                      throw
                      std::runtime_error(
                        "sc_add_data(): Some error occurred while accessing generic soft constraint callback data free() list for sequence alignment");
                  }

                  PyErr_Clear();
                } else if ((f != Py_None) && (!PyCallable_Check(f))) {
                  PyErr_SetString(PyExc_TypeError, "Require a callable object for free_data_cb!");
                  cb->delete_data = Py_None;
                  Py_INCREF(Py_None);
                } else {
                  cb->delete_data = f; /* remember delete data function */
                  Py_INCREF(f);
                }
              } else {
                cb->delete_data = Py_None;
                Py_INCREF(Py_None);
              }
            }

            vc->scs[s]->data = (void *)cb;

            /* also (re-)bind the free-callback-data function */
            vc->scs[s]->free_data = &delete_py_sc_callback;
          }

          return 1;
        } else {
          throw
          std::runtime_error(
            "sc_add_data(): Comparative prediction data must be provided as list or tuple");
        }

        break;
    }

    return 0;
  }


  static int
  py_wrap_sc_f_callback(int           i,
                        int           j,
                        int           k,
                        int           l,
                        unsigned char d,
                        void          *data)
  {
    int               ret;
    PyObject          *func, *arglist, *result, *err;
    py_sc_callback_t  *cb = (py_sc_callback_t *)data;

    ret   = 0;
    func  = cb->cb_f;

    /* compose argument list */
    PyObject *py_i, *py_j, *py_k, *py_l, *py_d;

    py_i    = PyLong_FromLong(i);
    py_j    = PyLong_FromLong(j);
    py_k    = PyLong_FromLong(k);
    py_l    = PyLong_FromLong(l);
    py_d    = PyLong_FromLong(d);
    result  = PyObject_CallFunctionObjArgs(func,
                                           py_i,
                                           py_j,
                                           py_k,
                                           py_l,
                                           py_d,
                                           (cb->data) ? cb->data : Py_None,
                                           NULL);

    Py_DECREF(py_i);
    Py_DECREF(py_j);
    Py_DECREF(py_k);
    Py_DECREF(py_l);
    Py_DECREF(py_d);

    /* BEGIN recognizing errors in callback execution */
    if (result == NULL) {
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
          throw
          std::runtime_error("Generic soft constraint callbacks must take exactly 6 arguments");


        else
          throw
          std::runtime_error(
            "Some error occurred while executing generic soft constraint callback");
      }

      PyErr_Clear();
    } else if (PyLong_Check(result)) {
      ret = (int)PyLong_AsLong(result);
    } else {
      throw
      std::runtime_error(
        "Generic soft constraint callback must return pseudo energy value in 10 cal/mol");
    }

    /* END recognizing errors in callback execution */

    Py_XDECREF(result);

    return ret;
  }


  static vrna_basepair_t *
  py_wrap_sc_bt_callback(int            i,
                         int            j,
                         int            k,
                         int            l,
                         unsigned char  d,
                         void           *data)
  {
    int               c, len, num_pairs;
    PyObject          *func, *arglist, *result, *bp, *err;
    py_sc_callback_t  *cb;
    vrna_basepair_t   *ptr, *pairs;

    cb    = (py_sc_callback_t *)data;
    pairs = NULL;
    func  = cb->cb_bt;
    /* compose argument list */
    PyObject *py_i, *py_j, *py_k, *py_l, *py_d;

    py_i    = PyLong_FromLong(i);
    py_j    = PyLong_FromLong(j);
    py_k    = PyLong_FromLong(k);
    py_l    = PyLong_FromLong(l);
    py_d    = PyLong_FromLong(d);
    result  = PyObject_CallFunctionObjArgs(func,
                                           py_i,
                                           py_j,
                                           py_k,
                                           py_l,
                                           py_d,
                                           (cb->data) ? cb->data : Py_None,
                                           NULL);

    Py_DECREF(py_i);
    Py_DECREF(py_j);
    Py_DECREF(py_k);
    Py_DECREF(py_l);
    Py_DECREF(py_d);

    /* BEGIN recognizing errors in callback execution */
    if (result == NULL) {
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
          throw
          std::runtime_error("Generic soft constraint callbacks must take exactly 6 arguments");


        else
          throw
          std::runtime_error(
            "Some error occurred while executing generic soft constraint callback");
      }

      PyErr_Clear();
      return NULL;
    }

    /* END recognizing errors in callback execution */

    if (PyList_Check(result)) {
      len       = 10;
      num_pairs = 0;
      pairs     = (vrna_basepair_t *)vrna_alloc(sizeof(vrna_basepair_t) * len);

      /* result should be list of pairs */
      for (c = 0; c < PyList_Size(result); c++) {
        bp = PyList_GetItem(result, c);
        /* maybe the user was so kind to create a list of vrna_basepair_t? */
        if (SWIG_ConvertPtr(bp, (void **)&ptr, SWIGTYPE_p_vrna_basepair_t,
                            SWIG_POINTER_EXCEPTION) == 0) {
          pairs[num_pairs] = *ptr;
          num_pairs++;
        }
        /* users may also specify base pairs as tuples of size 2 */
        else if (PyTuple_Check(bp)) {
          if ((PyTuple_Size(bp) == 2)
              && PyLong_Check(PyTuple_GetItem(bp, 0))
              && PyLong_Check(PyTuple_GetItem(bp, 1))) {
            pairs[num_pairs].i  = (int)PyLong_AsLong(PyTuple_GetItem(bp, 0));
            pairs[num_pairs].j  = (int)PyLong_AsLong(PyTuple_GetItem(bp, 1));
            num_pairs++;
          }
        }
        /* or is it even a dictionary with i j keys? */
        else if (PyDict_Check(bp)) {
          /* check whether the dictionary actually contains the correct keys */
          PyObject *bp_i, *bp_j;
          bp_i  = PyDict_GetItemString(bp, "i");
          bp_j  = PyDict_GetItemString(bp, "j");
          /* both dictionary keys must be present and the corresponding values have to be integer types */
          if (bp_i && bp_j && PyLong_Check(bp_i) && PyLong_Check(bp_j)) {
            pairs[num_pairs].i  = (int)PyLong_AsLong(bp_i);
            pairs[num_pairs].j  = (int)PyLong_AsLong(bp_j);
            num_pairs++;
          }
        } else {
          continue;
        }

        /* increase length if necessary */
        if (num_pairs == len) {
          len   = (int)(1.2 * len);
          pairs = (vrna_basepair_t *)vrna_realloc(pairs, sizeof(vrna_basepair_t) * len);
        }
      }
      /* put end marker in list */
      pairs[num_pairs].i  = pairs[num_pairs].j = 0;
      pairs               =
        (vrna_basepair_t *)vrna_realloc(pairs, sizeof(vrna_basepair_t) * (num_pairs + 1));
    }

    Py_XDECREF(result);
    return pairs;
  }


  static FLT_OR_DBL
  py_wrap_sc_exp_f_callback(int           i,
                            int           j,
                            int           k,
                            int           l,
                            unsigned char d,
                            void          *data)
  {
    FLT_OR_DBL        ret;
    PyObject          *func, *arglist, *result, *err;
    py_sc_callback_t  *cb;

    cb    = (py_sc_callback_t *)data;
    ret   = 1.;
    func  = cb->cb_exp_f;
    /* compose argument list */
    PyObject *py_i, *py_j, *py_k, *py_l, *py_d;

    py_i  = PyLong_FromLong(i);
    py_j  = PyLong_FromLong(j);
    py_k  = PyLong_FromLong(k);
    py_l  = PyLong_FromLong(l);
    py_d  = PyLong_FromLong(d);

    result = PyObject_CallFunctionObjArgs(func,
                                          py_i,
                                          py_j,
                                          py_k,
                                          py_l,
                                          py_d,
                                          (cb->data) ? cb->data : Py_None,
                                          NULL);
    Py_DECREF(py_i);
    Py_DECREF(py_j);
    Py_DECREF(py_k);
    Py_DECREF(py_l);
    Py_DECREF(py_d);

    /* BEGIN recognizing errors in callback execution */
    if (result == NULL) {
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
          throw
          std::runtime_error(
            "Generic soft constraint callbacks (partition function) must take exactly 6 arguments");


        else
          throw
          std::runtime_error(
            "Some error occurred while executing generic soft constraint callback (partition function)");
      }

      PyErr_Clear();
    } else if (result == Py_None) {
      throw
      std::runtime_error(
        "Generic soft constraint callback (partition function) must return Boltzmann weighted pseudo energy value");
    } else {
      ret = (FLT_OR_DBL)PyFloat_AsDouble(result);
    }

    /* END recognizing errors in callback execution */

    Py_XDECREF(result);
    return ret;
  }





#include <stdexcept>

typedef struct {
  PyObject  *prod_rule;
  PyObject  *exp_prod_rule;
  PyObject  *energy;
  PyObject  *exp_energy;
  PyObject  *data;
  PyObject  *delete_data;
  PyObject  *prob_add;
  PyObject  *prob_get;
} py_ud_callback_t;


static py_ud_callback_t *
new_py_ud_cb(void);


static void
delete_py_ud_data(py_ud_callback_t *cb);


static void
delete_py_ud_callback(void * data);


static void
ud_set_pydata(vrna_fold_compound_t *vc,
              PyObject             *data,
              PyObject             *PyFunc);


static void
ud_set_prod_cb(vrna_fold_compound_t *vc,
               PyObject             *prod_cb,
               PyObject             *eval_cb);


static void
ud_set_exp_prod_cb(vrna_fold_compound_t *vc,
                   PyObject             *prod_cb,
                   PyObject             *eval_cb);


static void
ud_set_prob_cb(vrna_fold_compound_t *vc,
               PyObject             *setter,
               PyObject             *getter);


static void
py_wrap_ud_prod_rule(vrna_fold_compound_t *vc,
                     void                 *data);


static void
py_wrap_ud_exp_prod_rule(vrna_fold_compound_t *vc,
                         void                 *data);


static int
py_wrap_ud_energy(vrna_fold_compound_t *vc,
                  int                  i,
                  int                  j,
                  unsigned int         looptype,
                  void                 *data);


static FLT_OR_DBL
py_wrap_ud_exp_energy(vrna_fold_compound_t *vc,
                      int                  i,
                      int                  j,
                      unsigned int         looptype,
                      void                 *data);


static void
py_wrap_ud_prob_add(vrna_fold_compound_t *vc,
                    int                  i,
                    int                  j,
                    unsigned int         looptype,
                    FLT_OR_DBL           prob,
                    void                 *data);


static FLT_OR_DBL
py_wrap_ud_prob_get(vrna_fold_compound_t *vc,
                    int                  i,
                    int                  j,
                    unsigned int         looptype,
                    int                  motif,
                    void                 *data);

static py_ud_callback_t *
new_py_ud_cb(void){

  py_ud_callback_t *cb = (py_ud_callback_t *)vrna_alloc(sizeof(py_ud_callback_t));

  Py_INCREF(Py_None);
  cb->prod_rule     = Py_None;
  Py_INCREF(Py_None);
  cb->exp_prod_rule = Py_None;
  Py_INCREF(Py_None);
  cb->energy        = Py_None;
  Py_INCREF(Py_None);
  cb->exp_energy    = Py_None;
  Py_INCREF(Py_None);
  cb->data          = Py_None;
  Py_INCREF(Py_None);
  cb->delete_data   = Py_None;
  Py_INCREF(Py_None);
  cb->prob_add      = Py_None;
  Py_INCREF(Py_None);
  cb->prob_get      = Py_None;

  return cb;
}

static void
delete_py_ud_data(py_ud_callback_t *cb)
{
  if ((cb->data != Py_None) &&
      (cb->delete_data != Py_None)) {
    PyObject *func, *arglist, *result, *err;
    func = cb->delete_data;
    arglist = Py_BuildValue("O", cb->data);
    result  = PyObject_CallObject(func, arglist);

    /* BEGIN recognizing errors in callback execution */
    if (result == NULL) {
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
          throw std::runtime_error( "Unstructured domains delete_data() callback must take exactly 1 argument" );
        } else {
          throw std::runtime_error( "Some error occurred while executing unstructured domains delete_data() callback" );
        }
      }
      PyErr_Clear();
    }
    /* END recognizing errors in callback execution */

    Py_DECREF(arglist);
    Py_XDECREF(result);
  }
  Py_DECREF(cb->data);
  Py_DECREF(cb->delete_data);
}


static void
delete_py_ud_callback(void * data)
{
  py_ud_callback_t *cb = (py_ud_callback_t *)data;
  /* first delete user data */
  delete_py_ud_data(cb);

  /* now dispose of the registered callbacks */
  Py_DECREF(cb->prod_rule);
  Py_DECREF(cb->exp_prod_rule);
  Py_DECREF(cb->energy);
  Py_DECREF(cb->exp_energy);
  Py_DECREF(cb->prob_add);
  Py_DECREF(cb->prob_get);

  /* finally free pycallback */
  free(cb);
}


static void
ud_set_pydata(vrna_fold_compound_t *vc,
              PyObject             *data,
              PyObject             *PyFunc)
{

  py_ud_callback_t * cb;

  if ((vc->domains_up) &&
      (vc->domains_up->data)) {
    cb = (py_ud_callback_t *)vc->domains_up->data;
  } else {
    cb = new_py_ud_cb();
  }

  /* try to dispose of previous data */
  delete_py_ud_data(cb);

  /* increase reference counter */
  Py_INCREF(data);
  Py_INCREF(PyFunc);
  cb->data        = data;   /* remember data */
  cb->delete_data = PyFunc; /* remember delete data function */

  /* bind callback wrapper to fold compound */
  vrna_ud_set_data(vc, (void *)cb, &delete_py_ud_callback);
}


static void
ud_set_prod_cb(vrna_fold_compound_t *vc,
               PyObject             *prod_cb,
               PyObject             *eval_cb)
{

  /* try to dispose of previous callback */
  py_ud_callback_t * cb;
  if(vc->domains_up && vc->domains_up->data){
    cb = (py_ud_callback_t *)vc->domains_up->data;
  } else {
    cb = new_py_ud_cb();
    /* bind callback wrapper to fold compound */
    vrna_ud_set_data(vc, (void *)cb, &delete_py_ud_callback);
  }
  /* release previous callback */
  Py_DECREF(cb->prod_rule);
  Py_DECREF(cb->energy);

  Py_XINCREF(prod_cb);     /* Increase reference counter */
  Py_XINCREF(eval_cb);     /* Increase reference counter */

  cb->prod_rule = prod_cb; /* remember callback */
  cb->energy    = eval_cb; /* remember callback */

  vrna_ud_set_prod_rule_cb(vc, &py_wrap_ud_prod_rule, &py_wrap_ud_energy);
}


static void
ud_set_exp_prod_cb(vrna_fold_compound_t *vc,
                   PyObject             *prod_cb,
                   PyObject             *eval_cb)
{

  /* try to dispose of previous callback */
  py_ud_callback_t *cb;

  /* now bind the python function to the wrapper structure */
  if ((vc->domains_up) &&
      (vc->domains_up->data)) {
    cb = (py_ud_callback_t *)vc->domains_up->data;
  } else {
    cb = new_py_ud_cb();
    /* bind callback wrapper to fold compound */
    vrna_ud_set_data(vc, (void *)cb, &delete_py_ud_callback);
  }
  /* release previous callback */
  Py_DECREF(cb->exp_prod_rule);
  Py_DECREF(cb->exp_energy);

  Py_INCREF(prod_cb); /* Increase reference counter */
  Py_INCREF(eval_cb); /* Increase reference counter */

  cb->exp_prod_rule = prod_cb;
  cb->exp_energy    = eval_cb;


  vrna_ud_set_exp_prod_rule_cb(vc, &py_wrap_ud_exp_prod_rule, &py_wrap_ud_exp_energy);
}


static void
ud_set_prob_cb(vrna_fold_compound_t *vc,
               PyObject             *setter,
               PyObject             *getter)
{

  py_ud_callback_t *cb;

  /* now bind the python function to the wrapper structure */
  if ((vc->domains_up) &&
      (vc->domains_up->data)) {
    cb = (py_ud_callback_t *)vc->domains_up->data;
  } else {
    cb = new_py_ud_cb();
    /* bind callback wrapper to fold compound */
    vrna_ud_set_data(vc, (void *)cb, &delete_py_ud_callback);
  }
  /* release previous callbacks */
  Py_DECREF(cb->prob_add);
  Py_DECREF(cb->prob_get);

  Py_INCREF(setter); /* Increase reference counter */
  Py_INCREF(getter); /* Increase reference counter */

  cb->prob_add = setter;
  cb->prob_get = getter;

  vrna_ud_set_prob_cb(vc, &py_wrap_ud_prob_add, &py_wrap_ud_prob_get);
}


static void
py_wrap_ud_prod_rule(vrna_fold_compound_t *vc,
                     void                 *data)
{
  PyObject          *func, *arglist, *result, *err;
  py_ud_callback_t  *cb;

  cb    = (py_ud_callback_t *)data;
  func  = cb->prod_rule;

  /* compose argument list */
  arglist = Py_BuildValue("(O,O)", vc, (cb->data) ? cb->data : Py_None);
  result =  PyObject_CallObject(func, arglist);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Unstructured domains production rule callback must take exactly 2 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing unstructured domains production rule callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_DECREF(arglist);
  Py_XDECREF(result);
  return /*void*/;
}


static void
py_wrap_ud_exp_prod_rule(vrna_fold_compound_t *vc,
                         void                 *data)
{
  PyObject          *func, *arglist, *result, *err;
  py_ud_callback_t  *cb;

  cb    = (py_ud_callback_t *)data;
  func  = cb->exp_prod_rule;

  /* compose argument list */
  arglist = Py_BuildValue("(O,O)", vc, (cb->data) ? cb->data : Py_None);
  result =  PyObject_CallObject(func, arglist);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Unstructured domains production rule callback (partition function) must take exactly 2 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing unstructured domains production rule callback (partition function)" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_DECREF(arglist);
  Py_XDECREF(result);
  return /*void*/;
}


static int
py_wrap_ud_energy(vrna_fold_compound_t *vc,
                  int                  i,
                  int                  j,
                  unsigned int         looptype,
                  void                 *data)
{
  int               ret;
  PyObject          *func, *arglist, *result, *err, *py_vc, *py_i, *py_j, *py_looptype;
  py_ud_callback_t  *cb;

  ret   = 0;
  cb    = (py_ud_callback_t *)data;
  func  = cb->energy;

  /* compose argument list */
  py_vc       = SWIG_NewPointerObj(SWIG_as_voidptr(vc),
                                   SWIGTYPE_p_vrna_fold_compound_t,
                                   0);
  py_i        = PyLong_FromLong(i);
  py_j        = PyLong_FromLong(j);
  py_looptype = PyLong_FromLong(looptype);
  result      = PyObject_CallFunctionObjArgs(func,
                                             py_vc,
                                             py_i,
                                             py_j,
                                             py_looptype,
                                             (cb->data) ? cb->data : Py_None,
                                             NULL);

  Py_DECREF(py_vc);
  Py_DECREF(py_i);
  Py_DECREF(py_j);
  Py_DECREF(py_looptype);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Unstructured domains energy callback must take exactly 5 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing unstructured domains energy callback" );
      }
    }
    PyErr_Clear();
  } else if (result == Py_None) {
    throw std::runtime_error( "Unstructured domains energy callback must return pseudo energy value" );
  } else {
    ret = (int)PyLong_AsLong(result);
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);
  return ret;
}


static FLT_OR_DBL
py_wrap_ud_exp_energy(vrna_fold_compound_t *vc,
                      int                  i,
                      int                  j,
                      unsigned int         looptype,
                      void                 *data)
{
  FLT_OR_DBL        ret;
  PyObject          *func, *arglist, *result, *err, *py_vc, *py_i, *py_j, *py_looptype;
  py_ud_callback_t  *cb;

  ret   = 1.;
  cb    = (py_ud_callback_t *)data;
  func  = cb->exp_energy;

  /* compose argument list */
  py_vc       = SWIG_NewPointerObj(SWIG_as_voidptr(vc),
                                   SWIGTYPE_p_vrna_fold_compound_t,
                                   0);
  py_i        = PyLong_FromLong(i);
  py_j        = PyLong_FromLong(j);
  py_looptype = PyLong_FromLong(looptype);
  result      = PyObject_CallFunctionObjArgs(func,
                                             py_vc,
                                             py_i,
                                             py_j,
                                             py_looptype,
                                             (cb->data) ? cb->data : Py_None,
                                             NULL);

  Py_DECREF(py_vc);
  Py_DECREF(py_i);
  Py_DECREF(py_j);
  Py_DECREF(py_looptype);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Unstructured domains energy callback (partition function) must take exactly 5 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing unstructured domains energy callback (partition function)" );
      }
    }
    PyErr_Clear();
  } else if (result == Py_None) {
    throw std::runtime_error( "Unstructured domains energy callback (partition function) must return Boltzmann weighted pseudo energy value" );
  } else {
    ret = (FLT_OR_DBL)PyFloat_AsDouble(result);
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);
  return ret;
}


static void
py_wrap_ud_prob_add(vrna_fold_compound_t *vc,
                    int                  i,
                    int                  j,
                    unsigned int         looptype,
                    FLT_OR_DBL           prob,
                    void                 *data)
{
  PyObject          *func, *arglist, *result, *err, *py_vc, *py_i, *py_j, *py_looptype, *py_prob;
  py_ud_callback_t  *cb;

  cb    = (py_ud_callback_t *)data;
  func  = cb->prob_add;

  /* compose argument list */
  py_vc       = SWIG_NewPointerObj(SWIG_as_voidptr(vc),
                                   SWIGTYPE_p_vrna_fold_compound_t,
                                   0);
  py_i        = PyLong_FromLong(i);
  py_j        = PyLong_FromLong(j);
  py_looptype = PyLong_FromLong(looptype);
  py_prob     = PyFloat_FromDouble((double)prob);
  result      = PyObject_CallFunctionObjArgs(func,
                                             py_vc,
                                             py_i,
                                             py_j,
                                             py_looptype,
                                             py_prob,
                                             (cb->data) ? cb->data : Py_None,
                                             NULL);

  Py_DECREF(py_vc);
  Py_DECREF(py_i);
  Py_DECREF(py_j);
  Py_DECREF(py_looptype);
  Py_DECREF(py_prob);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Unstructured domains add_probability() callback must take exactly 6 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing unstructured domains add_probability() callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);
  return;
}


static FLT_OR_DBL
py_wrap_ud_prob_get(vrna_fold_compound_t *vc,
                    int                  i,
                    int                  j,
                    unsigned int         looptype,
                    int                  motif,
                    void                 *data)
{
  FLT_OR_DBL        ret;
  PyObject          *func, *arglist, *result, *err, *py_vc, *py_i, *py_j, *py_looptype, *py_motif;
  py_ud_callback_t  *cb;

  ret   = 1.;
  cb    = (py_ud_callback_t *)data;
  func  = cb->prob_get;

  /* compose argument list */
  py_vc       = SWIG_NewPointerObj(SWIG_as_voidptr(vc),
                                   SWIGTYPE_p_vrna_fold_compound_t,
                                   0);
  py_i        = PyLong_FromLong(i);
  py_j        = PyLong_FromLong(j);
  py_looptype = PyLong_FromLong(looptype);
  py_motif    = PyLong_FromLong(motif);
  result      = PyObject_CallFunctionObjArgs(func,
                                             py_vc,
                                             py_i,
                                             py_j,
                                             py_looptype,
                                             py_motif,
                                             (cb->data) ? cb->data : Py_None,
                                             NULL);

  Py_DECREF(py_vc);
  Py_DECREF(py_i);
  Py_DECREF(py_j);
  Py_DECREF(py_looptype);
  Py_DECREF(py_motif);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Unstructured domains get_probability() callback must take exactly 6 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing unstructured domains get_probability() callback" );
      }
    }
    PyErr_Clear();
  } else if (result == Py_None) {
    throw std::runtime_error( "Unstructured domains get_probability() callback must return probability" );
  } else {
    ret = (FLT_OR_DBL)PyFloat_AsDouble(result);
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);
  return ret;
}




#include <stdexcept>

typedef struct {
  PyObject *cb;
  PyObject *data;
} python_subopt_callback_t;

static python_subopt_callback_t *
bind_subopt_callback(PyObject *PyFunc,
                     PyObject *data);

static void
python_wrap_subopt_cb(const char *structure,
                      float      energy,
                      void       *data);

static python_subopt_callback_t *
bind_subopt_callback(PyObject *PyFunc,
                     PyObject *data)
{

  python_subopt_callback_t *cb = (python_subopt_callback_t *)vrna_alloc(sizeof(python_subopt_callback_t));

  Py_INCREF(PyFunc);
  Py_INCREF(data);
  cb->cb    = PyFunc;  /* store callback */
  cb->data  = data;    /* bind data */

  return cb;
}

static void
release_subopt_callback(python_subopt_callback_t *cb)
{
  Py_DECREF(cb->cb);
  Py_DECREF(cb->data);
  free(cb); 
}


static void
python_wrap_subopt_cb(const char *structure,
                      float      energy,
                      void       *data)
{
  PyObject                  *func, *arglist, *result, *err, *py_structure, *py_energy;
  python_subopt_callback_t  *cb;

  cb    = (python_subopt_callback_t *)data;
  func  = cb->cb;

  /* compose argument list */
  py_structure = (structure) ? PyString_FromString(structure) : Py_None;
  py_energy    = PyFloat_FromDouble((double)energy);
  result       = PyObject_CallFunctionObjArgs(func,
                                              py_structure,
                                              py_energy,
                                              (cb->data) ? cb->data : Py_None,
                                              NULL);

  if (py_structure != Py_None)
    Py_DECREF(py_structure);

  Py_DECREF(py_energy);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Subopt callback must take exactly 3 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing subopt callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);

  return /*void*/;
}




#include <stdexcept>

typedef struct {
  PyObject *cb;
  PyObject *data;
} python_bs_callback_t;

static python_bs_callback_t *
bind_bs_callback(PyObject *PyFunc,
                 PyObject *data);

static void
python_wrap_bs_cb(const char *structure,
                  void       *data);

static python_bs_callback_t *
bind_bs_callback(PyObject *PyFunc,
                 PyObject *data)
{

  python_bs_callback_t *cb = (python_bs_callback_t *)vrna_alloc(sizeof(python_bs_callback_t));

  Py_INCREF(PyFunc);
  Py_INCREF(data);
  cb->cb    = PyFunc;  /* store callback */
  cb->data  = data;    /* bind data */

  return cb;
}

static void
release_bs_callback(python_bs_callback_t *cb)
{
  Py_DECREF(cb->cb);
  Py_DECREF(cb->data);
  free(cb); 
}

static void
python_wrap_bs_cb(const char *structure,
                  void       *data)
{
  PyObject *func, *arglist, *result, *err;
  python_bs_callback_t *cb = (python_bs_callback_t *)data;

  func = cb->cb;
  /* compose argument list */
  PyObject *py_structure, *py_energy;
  py_structure = (structure) ? PyString_FromString(structure) : Py_None;
  result       = PyObject_CallFunctionObjArgs(func,
                                              py_structure,
                                              (cb->data) ? cb->data : Py_None,
                                              NULL);

  if (py_structure != Py_None)
    Py_DECREF(py_structure);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Boltzmann sampling callback must take exactly 2 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing Boltzmann sampling callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);

  return /*void*/;
}




#include <stdexcept>

typedef struct {
  PyObject *cb;
  PyObject *data;
} python_mfe_window_callback_t;

static python_mfe_window_callback_t *
bind_mfe_window_callback(PyObject *PyFunc,
                         PyObject *data);


static void
python_wrap_mfe_window_cb(unsigned int  start,
                          unsigned int  end,
                          const char    *structure,
                          float         energy,
                          void          *data);

#ifdef VRNA_WITH_SVM
static void
python_wrap_mfe_window_zscore_cb(unsigned int start,
                                 unsigned int end,
                                 const char   *structure,
                                 float        energy,
                                 float        zscore,
                                 void         *data);
#endif

static python_mfe_window_callback_t *
bind_mfe_window_callback(PyObject *PyFunc,
                         PyObject *data)
{

  python_mfe_window_callback_t *cb = (python_mfe_window_callback_t *)vrna_alloc(sizeof(python_mfe_window_callback_t));

  Py_INCREF(PyFunc);
  Py_INCREF(data);

  cb->cb    = PyFunc;  /* store callback */
  cb->data  = data;    /* bind data */

  return cb;
}

static void
release_mfe_window_callback(python_mfe_window_callback_t *cb)
{
  Py_DECREF(cb->cb);
  Py_DECREF(cb->data);
  free(cb); 
}

static void
python_wrap_mfe_window_cb(unsigned int  start,
                          unsigned int  end,
                          const char    *structure,
                          float         energy,
                          void          *data)
{
  PyObject *func, *arglist, *result, *err;
  python_mfe_window_callback_t *cb = (python_mfe_window_callback_t *)data;

  func = cb->cb;
  /* compose argument list */
  PyObject *py_start, *py_end, *py_structure, *py_energy;
  py_start      = PyLong_FromUnsignedLong(start);
  py_end        = PyLong_FromUnsignedLong(end);
  py_structure  = PyString_FromString(structure);
  py_energy     = PyFloat_FromDouble((double)energy);
  result        = PyObject_CallFunctionObjArgs(func,
                                               py_start,
                                               py_end,
                                               py_structure,
                                               py_energy,
                                               (cb->data) ? cb->data : Py_None,
                                               NULL);

  Py_DECREF(py_start);
  Py_DECREF(py_end);
  Py_DECREF(py_structure);
  Py_DECREF(py_energy);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Sliding window MFE callback must take exactly 5 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing sliding window MFE callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);

  return /*void*/;
}

#ifdef VRNA_WITH_SVM
static void
python_wrap_mfe_window_zscore_cb(unsigned int start,
                                 unsigned int end,
                                 const char   *structure,
                                 float        energy,
                                 float        zscore,
                                 void         *data)
{

  PyObject *func, *arglist, *result, *err;
  python_mfe_window_callback_t *cb = (python_mfe_window_callback_t *)data;

  func = cb->cb;
  /* compose argument list */
  PyObject *py_start, *py_end, *py_structure, *py_energy, *py_zscore;
  py_start = PyLong_FromUnsignedLong(start);
  py_end   = PyLong_FromUnsignedLong(end);
  py_structure  = PyString_FromString(structure);
  py_energy     = PyFloat_FromDouble((double)energy);
  py_zscore     = PyFloat_FromDouble((double)zscore);
  result        = PyObject_CallFunctionObjArgs(func,
                                        py_start,
                                        py_end,
                                        py_structure,
                                        py_energy,
                                        py_zscore,
                                        (cb->data) ? cb->data : Py_None,
                                        NULL);
  Py_DECREF(py_start);
  Py_DECREF(py_end);
  Py_DECREF(py_structure);
  Py_DECREF(py_energy);
  Py_DECREF(py_zscore);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Sliding window MFE callback (z-score) must take exactly 6 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing sliding window MFE callback (z-score)" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);

  return /*void*/;
}
#endif



  float
  my_Lfold_cb(char      *string,
              int       window_size,
              PyObject  *PyFunc,
              PyObject  *data = Py_None)
  {
    float en;
    python_mfe_window_callback_t *cb = bind_mfe_window_callback(PyFunc, data);
    en = vrna_Lfold_cb(string, window_size, &python_wrap_mfe_window_cb, (void *)cb);
    release_mfe_window_callback(cb);
    return en;
  }

#ifdef VRNA_WITH_SVM
  float
  my_Lfoldz_cb(char *   string,
               int      window_size,
               double   min_z,
               PyObject *PyFunc,
               PyObject *data = Py_None)
  {
    float en;
    python_mfe_window_callback_t *cb = bind_mfe_window_callback(PyFunc, data);
    en = vrna_Lfoldz_cb(string, window_size, min_z, &python_wrap_mfe_window_zscore_cb, (void *)cb);
    release_mfe_window_callback(cb);
    return en;
  }
#endif

  float
  my_aliLfold_cb(std::vector<std::string> alignment,
                 int                      window_size,
                 PyObject                 *PyFunc,
                 PyObject                 *data = Py_None)
  {
    float en;
    python_mfe_window_callback_t *cb = bind_mfe_window_callback(PyFunc, data);
    std::vector<const char*>  vc;
    std::transform(alignment.begin(), alignment.end(), std::back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */
    en = vrna_aliLfold_cb((const char **)&vc[0], window_size, &python_wrap_mfe_window_cb, (void *)cb);
    release_mfe_window_callback(cb);
    return en;
  }




#include <stdexcept>

typedef struct {
  PyObject *cb;
  PyObject *data;
} python_pf_window_callback_t;


static python_pf_window_callback_t *
bind_pf_window_callback(PyObject *PyFunc,
                        PyObject *data);


static void
python_wrap_pf_window_cb(FLT_OR_DBL   *pr,
                         int          pr_size,
                         int          i,
                         int          max,
                         unsigned int type,
                         void         *data);


static python_pf_window_callback_t *
bind_pf_window_callback(PyObject *PyFunc,
                        PyObject *data)
{
  python_pf_window_callback_t *cb = (python_pf_window_callback_t *)vrna_alloc(sizeof(python_pf_window_callback_t));

  Py_INCREF(PyFunc);
  Py_INCREF(data);

  cb->cb    = PyFunc;  /* store callback */
  cb->data  = data;    /* bind data */

  return cb;
}


static void
release_pf_window_callback(python_pf_window_callback_t *cb)
{
  Py_DECREF(cb->cb);
  Py_DECREF(cb->data);
  free(cb); 
}


static void
python_wrap_pf_window_cb(FLT_OR_DBL   *pr,
                         int          pr_size,
                         int          i,
                         int          max,
                         unsigned int type,
                         void *data)
{
  PyObject *func, *arglist, *result, *pr_list, *err;
  python_pf_window_callback_t *cb = (python_pf_window_callback_t *)data;

  func = cb->cb;

  if (type & VRNA_PROBS_WINDOW_UP) { /* We distinguish output for unpaired probabilities */

    /* create PYTHON list for unpaired probabilities */
    pr_list = PyList_New((Py_ssize_t) max + 1);

    /* 0th element */
    Py_INCREF(Py_None);
    PyList_SET_ITEM(pr_list, 0, Py_None);

    /* actual values in range [1, MIN(i, max)] */
    for (int cnt = 1; cnt <= pr_size; cnt++)
      PyList_SET_ITEM(pr_list, (Py_ssize_t) cnt, PyFloat_FromDouble(pr[cnt]));

    /* empty values in range [0,i - 1] */
    for (int cnt = pr_size + 1; cnt <= max; cnt++) {
      Py_INCREF(Py_None);
      PyList_SET_ITEM(pr_list, (Py_ssize_t) cnt, Py_None);
    }
  } else { /* and pairing/stacking probabilities for pair (i, j) or ensemble free energies for subsegment [i, j] */

    /* create PYTHON list for pr values */
    pr_list = PyList_New((Py_ssize_t) (pr_size + 1));

    /* empty values in range [0, i] */
    for (int cnt = 0; cnt <= i; cnt++) {
      Py_INCREF(Py_None);
      PyList_SET_ITEM(pr_list, (Py_ssize_t) cnt, Py_None);
    }

    /* actual values in range [i + 1, pr_size] */
    for (int cnt = i + 1; cnt <= pr_size; cnt++)
      PyList_SET_ITEM(pr_list, (Py_ssize_t) cnt, PyFloat_FromDouble(pr[cnt]));
  }

  /* compose argument list */
  PyObject *py_size, *py_i, *py_max, *py_type;
  py_size = PyLong_FromLong(pr_size);
  py_i    = PyLong_FromLong(i);
  py_max  = PyLong_FromLong(max);
  py_type = PyLong_FromLong(type);
  result  = PyObject_CallFunctionObjArgs(func,
                                         pr_list,
                                         py_size,
                                         py_i,
                                         py_max,
                                         py_type,
                                         (cb->data) ? cb->data : Py_None,
                                         NULL);

  Py_DECREF(py_size);
  Py_DECREF(py_i);
  Py_DECREF(py_max);
  Py_DECREF(py_type);
  Py_DECREF(pr_list);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "Sliding window partition function callback must take exactly 6 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing sliding window partition function callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);

  return /*void*/;
}




  int
  pfl_fold_cb(std::string sequence,
              int         window_size,
              int         max_bp_span,
              PyObject    *PyFunc,
              PyObject    *data = Py_None)
  {
    python_pf_window_callback_t *cb = bind_pf_window_callback(PyFunc, data);
    int r = vrna_pfl_fold_cb(sequence.c_str(), window_size, max_bp_span, &python_wrap_pf_window_cb, (void *)cb);
    release_pf_window_callback(cb);
    return r;
  }

  int
  pfl_fold_up_cb(std::string  sequence,
                 int          ulength,
                 int          window_size,
                 int          max_bp_span,
                 PyObject     *PyFunc,
                 PyObject     *data = Py_None)
  {
    python_pf_window_callback_t *cb = bind_pf_window_callback(PyFunc, data);
    int r = vrna_pfl_fold_up_cb(sequence.c_str(), ulength, window_size, max_bp_span, &python_wrap_pf_window_cb, (void *)cb);
    release_pf_window_callback(cb);
    return r;
  }




#include <stdexcept>

typedef struct {
  PyObject *cb;
  PyObject *data;
} python_heat_capacity_callback_t;

static python_heat_capacity_callback_t *
bind_heat_capacity_callback(PyObject *PyFunc,
                            PyObject *data);

static void
python_wrap_heat_capacity_cb(float      temp,
                             float      hc,
                             void       *data);

static python_heat_capacity_callback_t *
bind_heat_capacity_callback(PyObject *PyFunc,
                            PyObject *data)
{

  python_heat_capacity_callback_t *cb = (python_heat_capacity_callback_t *)vrna_alloc(sizeof(python_heat_capacity_callback_t));

  Py_INCREF(PyFunc);
  Py_INCREF(data);
  cb->cb    = PyFunc;  /* store callback */
  cb->data  = data;    /* bind data */

  return cb;
}

static void
release_heat_capacity_callback(python_heat_capacity_callback_t *cb)
{
  Py_DECREF(cb->cb);
  Py_DECREF(cb->data);
  free(cb);
}


static void
python_wrap_heat_capacity_cb(float temp,
                             float hc,
                             void  *data)
{
  PyObject                        *func, *arglist, *result, *err, *py_temp, *py_hc;
  python_heat_capacity_callback_t *cb;

  cb    = (python_heat_capacity_callback_t *)data;
  func  = cb->cb;

  /* compose argument list */
  py_temp = PyFloat_FromDouble((double)temp);
  py_hc   = PyFloat_FromDouble((double)hc);
  result  = PyObject_CallFunctionObjArgs(func,
                                         py_temp,
                                         py_hc,
                                         (cb->data) ? cb->data : Py_None,
                                         NULL);

  Py_DECREF(py_temp);
  Py_DECREF(py_hc);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "heat_capacity callback must take exactly 3 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing heat_capacity callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);

  return /*void*/;
}




#include <stdexcept>

typedef struct {
  PyObject  *cb;
  PyObject  *data;
} pycallback_simple_t;


static pycallback_simple_t *
bind_simple_callback(PyObject *PyFunc,
                     PyObject *data);

static void
python_wrap_move_update_cb(vrna_fold_compound_t *fc,
                           vrna_move_t          neighbor,
                           unsigned int         state,
                           void                 *data);

static void
release_simple_callback(pycallback_simple_t *cb);


static pycallback_simple_t *
bind_simple_callback(PyObject *PyFunc,
                     PyObject *data)
{

  pycallback_simple_t *cb = (pycallback_simple_t *)vrna_alloc(sizeof(pycallback_simple_t));

  Py_INCREF(PyFunc);
  Py_INCREF(data);
  cb->cb    = PyFunc;  /* store callback */
  cb->data  = data;    /* bind data */

  return cb;
}

static void
release_simple_callback(pycallback_simple_t *cb)
{
  Py_DECREF(cb->cb);
  Py_DECREF(cb->data);
  free(cb);
}


static void
python_wrap_move_update_cb(vrna_fold_compound_t *fc,
                           vrna_move_t          neighbor,
                           unsigned int         state,
                           void                 *data)
{
  PyObject            *func, *arglist, *result, *err, *py_fc, *py_neighbor, *py_state;
  pycallback_simple_t *cb;

  cb    = (pycallback_simple_t *)data;
  func  = cb->cb;

  /* compose argument list */
  py_fc       = SWIG_NewPointerObj(SWIG_as_voidptr(fc),
                                   SWIGTYPE_p_vrna_fold_compound_t,
                                   0);
  py_neighbor = SWIG_NewPointerObj(SWIG_as_voidptr(&neighbor),
                                   SWIGTYPE_p_vrna_move_t,
                                   0);
  py_state    = PyLong_FromLong((long int)state);
  result      = PyObject_CallFunctionObjArgs(func,
                                           py_fc,
                                           py_neighbor,
                                           py_state,
                                           (cb->data) ? cb->data : Py_None,
                                           NULL);

  Py_DECREF(py_fc);
  Py_DECREF(py_neighbor);
  Py_DECREF(py_state);

  /* BEGIN recognizing errors in callback execution */
  if (result == NULL) {
    if ((err = PyErr_Occurred())) {
      /* print error message */
      PyErr_Print();
      /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
      if (PyErr_GivenExceptionMatches(err, PyExc_TypeError)) {
        throw std::runtime_error( "move_neighbor_diff callback must take exactly 4 arguments" );
      } else {
        throw std::runtime_error( "Some error occurred while executing move_neighbor_diff callback" );
      }
    }
    PyErr_Clear();
  }
  /* END recognizing errors in callback execution */

  Py_XDECREF(result);

  return /*void*/;
}



#include <stdexcept>

  typedef struct {
    PyObject  *f;
    PyObject  *exp_f;
    PyObject  *data;
    PyObject  *prepare_data;
    PyObject  *delete_data;
  } py_sc_cb_direct_t;


  static int
  py_wrap_sc_direct_f_callback(vrna_fold_compound_t *fc,
                               int                  i,
                               int                  j,
                               int                  k,
                               int                  l,
                               void                 *data);


  static FLT_OR_DBL
  py_wrap_sc_direct_exp_f_callback(vrna_fold_compound_t *fc,
                                   int                  i,
                                   int                  j,
                                   int                  k,
                                   int                  l,
                                   void                 *data);


  static int
  py_wrap_sc_direct_data_prepare_callback(vrna_fold_compound_t  *fc,
                                          void                  *data,
                                          unsigned int          event,
                                          void                  *event_data);


  static void
  delete_py_sc_direct_data(py_sc_cb_direct_t *cb)
  {
    if ((cb->data != Py_None) &&
        (cb->delete_data != Py_None)) {
      PyObject *func, *arglist, *result, *err;
      func    = cb->delete_data;
      arglist = Py_BuildValue("O", cb->data);
      result  = PyObject_CallObject(func, arglist);

      /* BEGIN recognizing errors in callback execution */
      if (result == NULL) {
        if ((err = PyErr_Occurred())) {
          /* print error message */
          PyErr_Print();
          /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
          if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
            throw
            std::runtime_error(
              "Generic soft constraint delete_data() callback must take exactly 1 argument");


          else
            throw
            std::runtime_error(
              "Some error occurred while executing generic soft constraint delete_data() callback");
        }

        PyErr_Clear();
      }

      /* END recognizing errors in callback execution */

      Py_DECREF(arglist);
      Py_XDECREF(result);
    }

    Py_DECREF(cb->data);
    Py_DECREF(cb->prepare_data);
    Py_DECREF(cb->delete_data);
  }


  static void
  delete_py_sc_direct_callback(void *data)
  {
    py_sc_cb_direct_t *cb = (py_sc_cb_direct_t *)data;

    /* first delete user data */
    delete_py_sc_direct_data(cb);

    /* now dispose of the registered callbacks */
    Py_DECREF(cb->f);
    Py_DECREF(cb->exp_f);

    /* finally free pycallback */
    free(cb);
  }


  static int
  sc_multi_cb_add_pycallback(vrna_fold_compound_t *fc,
                             PyObject             *f,
                             PyObject             *exp_f,
                             PyObject             *data,
                             PyObject             *data_prepare,
                             PyObject             *data_free,
                             unsigned int         decomp_type)
  {
    unsigned char     func_is_tuple, func_is_list;
    unsigned int      s;
    py_sc_cb_direct_t *cb;

    switch (fc->type) {
      case VRNA_FC_TYPE_SINGLE:
        if (!PyCallable_Check(f)) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object for argument f!");
        } else if ((exp_f != Py_None) && (!PyCallable_Check(exp_f))) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object for argument exp_f!");
        } else if ((data_prepare != Py_None) && (!PyCallable_Check(data_prepare))) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object for argument data_prepare!");
        } else if ((data_free != Py_None) && (!PyCallable_Check(data_free))) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object for argument data_free!");
        } else {
          /* if we get to this point, at least cb is pointing to a callable object */
          cb = (py_sc_cb_direct_t *)vrna_alloc(sizeof(py_sc_cb_direct_t));

          cb->f = f;                        /* remember callback */
          Py_INCREF(f);                     /* Increase referenc counter */

          cb->exp_f = exp_f;                /* remember callback */
          Py_INCREF(exp_f);                 /* Increase reference counter */

          cb->prepare_data = data_prepare;  /* remember callback */
          Py_INCREF(data_prepare);          /* Increase reference counter */

          cb->delete_data = data_free;      /* remember callback */
          Py_INCREF(data_free);             /* Increase reference counter */

          cb->data = data;                  /* remember data */
          Py_INCREF(data);                  /* Increase reference counter */

          return vrna_sc_multi_cb_add(fc,
                                      &py_wrap_sc_direct_f_callback,
                                      &py_wrap_sc_direct_exp_f_callback,
                                      (void *)cb,
                                      &py_wrap_sc_direct_data_prepare_callback,
                                      &delete_py_sc_direct_callback,
                                      decomp_type);
        }

        break;

      case VRNA_FC_TYPE_COMPARATIVE:
        throw
        std::runtime_error("sc_multi_cb_add(): Not implemented for comparative fold compound yet!");


        break;
    }

    return 0;
  }


  static int
  py_wrap_sc_direct_f_callback(vrna_fold_compound_t *fc,
                               int                  i,
                               int                  j,
                               int                  k,
                               int                  l,
                               void                 *data)
  {
    int               ret;
    PyObject          *func, *arglist, *result, *err;
    py_sc_callback_t  *cb = (py_sc_callback_t *)data;

    ret   = 0;
    func  = cb->cb_f;

    /* compose argument list */
    PyObject *py_fc, *py_i, *py_j, *py_k, *py_l;

    py_fc = SWIG_NewPointerObj(SWIG_as_voidptr(fc),
                               SWIGTYPE_p_vrna_fold_compound_t,
                               0);
    py_i    = PyLong_FromLong(i);
    py_j    = PyLong_FromLong(j);
    py_k    = PyLong_FromLong(k);
    py_l    = PyLong_FromLong(l);
    result  = PyObject_CallFunctionObjArgs(func,
                                           py_fc,
                                           py_i,
                                           py_j,
                                           py_k,
                                           py_l,
                                           (cb->data) ? cb->data : Py_None,
                                           NULL);

    Py_DECREF(py_fc);
    Py_DECREF(py_i);
    Py_DECREF(py_j);
    Py_DECREF(py_k);
    Py_DECREF(py_l);

    /* BEGIN recognizing errors in callback execution */
    if (result == NULL) {
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
          throw
          std::runtime_error(
            "Generic direct soft constraint callbacks must take exactly 6 arguments");


        else
          throw
          std::runtime_error(
            "Some error occurred while executing generic direct soft constraint callback");
      }

      PyErr_Clear();
    } else if (PyLong_Check(result)) {
      ret = (int)PyLong_AsLong(result);
    } else {
      throw
      std::runtime_error(
        "Generic direct soft constraint callback must return pseudo energy value in 10 cal/mol");
    }

    /* END recognizing errors in callback execution */

    Py_XDECREF(result);

    return ret;
  }


  static FLT_OR_DBL
  py_wrap_sc_direct_exp_f_callback(vrna_fold_compound_t *fc,
                                   int                  i,
                                   int                  j,
                                   int                  k,
                                   int                  l,
                                   void                 *data)
  {
    FLT_OR_DBL        ret;
    PyObject          *func, *arglist, *result, *err;
    py_sc_callback_t  *cb;

    cb    = (py_sc_callback_t *)data;
    ret   = 1.;
    func  = cb->cb_exp_f;
    /* compose argument list */
    PyObject *py_fc, *py_i, *py_j, *py_k, *py_l;

    py_fc = SWIG_NewPointerObj(SWIG_as_voidptr(fc),
                               SWIGTYPE_p_vrna_fold_compound_t,
                               0);
    py_i  = PyLong_FromLong(i);
    py_j  = PyLong_FromLong(j);
    py_k  = PyLong_FromLong(k);
    py_l  = PyLong_FromLong(l);

    result = PyObject_CallFunctionObjArgs(func,
                                          py_fc,
                                          py_i,
                                          py_j,
                                          py_k,
                                          py_l,
                                          (cb->data) ? cb->data : Py_None,
                                          NULL);
    Py_DECREF(py_fc);
    Py_DECREF(py_i);
    Py_DECREF(py_j);
    Py_DECREF(py_k);
    Py_DECREF(py_l);

    /* BEGIN recognizing errors in callback execution */
    if (result == NULL) {
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
          throw
          std::runtime_error(
            "Generic direct soft constraint callbacks (partition function) must take exactly 6 arguments");


        else
          throw
          std::runtime_error(
            "Some error occurred while executing generic direct soft constraint callback (partition function)");
      }

      PyErr_Clear();
    } else if (result == Py_None) {
      throw
      std::runtime_error(
        "Generic direct soft constraint callback (partition function) must return Boltzmann weighted pseudo energy value");
    } else {
      ret = (FLT_OR_DBL)PyFloat_AsDouble(result);
    }

    /* END recognizing errors in callback execution */

    Py_XDECREF(result);
    return ret;
  }


  static int
  py_wrap_sc_direct_data_prepare_callback(vrna_fold_compound_t  *fc,
                                          void                  *data,
                                          unsigned int          event,
                                          void                  *event_data)
  {
    int               ret;
    PyObject          *func, *arglist, *result, *err;
    py_sc_cb_direct_t *cb = (py_sc_cb_direct_t *)data;

    ret   = 0;
    func  = cb->prepare_data;

    /* compose argument list */
    PyObject *py_fc, *py_event, *py_event_data;

    py_fc = SWIG_NewPointerObj(SWIG_as_voidptr(fc),
                               SWIGTYPE_p_vrna_fold_compound_t,
                               0);
    py_event = PyLong_FromLong(event);
    if (event_data) {
      py_event_data = PyLong_FromLong(*((unsigned int *)event_data));
    } else {
      py_event_data = Py_None;
      Py_INCREF(Py_None);
    }

    result = PyObject_CallFunctionObjArgs(func,
                                          py_fc,
                                          (cb->data) ? cb->data : Py_None,
                                          py_event,
                                          py_event_data,
                                          NULL);

    Py_DECREF(py_fc);
    Py_DECREF(py_event);
    Py_DECREF(py_event_data);

    /* BEGIN recognizing errors in callback execution */
    if (result == NULL) {
      if ((err = PyErr_Occurred())) {
        /* print error message */
        PyErr_Print();
        /* we only treat TypeErrors differently here, as they indicate that the callback does not follow requirements! */
        if (PyErr_GivenExceptionMatches(err, PyExc_TypeError))
          throw
          std::runtime_error(
            "Generic direct soft constraint data prepapre callback must take exactly 4 arguments");


        else
          throw
          std::runtime_error(
            "Some error occurred while executing generic direct soft constraint data prepare callback");
      }

      PyErr_Clear();
    } else if (PyLong_Check(result)) {
      ret = (int)PyLong_AsLong(result);
    } else {
      throw
      std::runtime_error(
        "Generic direct soft constraint data prepare callback must return integer value");
    }

    /* END recognizing errors in callback execution */

    Py_XDECREF(result);

    return ret;
  }




  typedef enum {
    FC_TYPE_SINGLE      = VRNA_FC_TYPE_SINGLE,
    FC_TYPE_COMPARATIVE = VRNA_FC_TYPE_COMPARATIVE
  } my_fc_type_e;

SWIGINTERN void vrna_fold_compound_t_params_reset(vrna_fold_compound_t *self,vrna_md_t *md=NULL){
    vrna_params_reset(self, md);
  }
SWIGINTERN void vrna_fold_compound_t_params_subst(vrna_fold_compound_t *self,vrna_param_t *par=NULL){
    vrna_params_subst(self, par);
  }
SWIGINTERN void vrna_fold_compound_t_exp_params_rescale__SWIG_0(vrna_fold_compound_t *self){
    vrna_exp_params_rescale(self, NULL);
  }
SWIGINTERN void vrna_fold_compound_t_exp_params_rescale__SWIG_1(vrna_fold_compound_t *self,double fe){
    vrna_exp_params_rescale(self, &fe);
  }
SWIGINTERN void vrna_fold_compound_t_exp_params_reset(vrna_fold_compound_t *self,vrna_md_t *md=NULL){
    vrna_exp_params_reset(self, md);
  }
SWIGINTERN void vrna_fold_compound_t_exp_params_subst(vrna_fold_compound_t *self,vrna_exp_param_t *par){
    vrna_exp_params_subst(self, par);
  }
SWIGINTERN std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > vrna_fold_compound_t_plist_from_probs(vrna_fold_compound_t *self,double cutoff){
    std::vector<vrna_ep_t > ep_v;
    vrna_ep_t               *ptr, *plist;

    plist = vrna_plist_from_probs(self, cutoff);

    for (ptr = plist; ptr->i && ptr->j; ptr++) {
      vrna_ep_t pl;
      pl.i = ptr->i;
      pl.j = ptr->j;
      pl.p = ptr->p;
      pl.type = ptr->type;
      ep_v.push_back(pl);
    }

    free(plist);

    return ep_v;
  }
SWIGINTERN std::string vrna_fold_compound_t_db_from_probs(vrna_fold_compound_t *self){
    if ((self->exp_matrices) &&
        (self->exp_matrices->probs)) {
      char *propensities = vrna_db_from_probs(self->exp_matrices->probs,
                                              self->length);

      std::string prop_string(propensities);

      free(propensities);

      return prop_string;
    }

    return std::string("");
  }
SWIGINTERN void vrna_fold_compound_t_constraints_add(vrna_fold_compound_t *self,char const *constraint,unsigned int options=VRNA_OPTION_MFE){
    vrna_constraints_add(self,constraint, options);
  }
SWIGINTERN void vrna_fold_compound_t_hc_init(vrna_fold_compound_t *self){
    vrna_hc_init(self);
  }
SWIGINTERN void vrna_fold_compound_t_hc_add_up(vrna_fold_compound_t *self,unsigned int i,unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS){
    vrna_hc_add_up_strand(self, i, -1, (unsigned char)option);
  }
SWIGINTERN void vrna_fold_compound_t_hc_add_up_strand(vrna_fold_compound_t *self,unsigned int i,int strand=-1,unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS){
    vrna_hc_add_up_strand(self, i, strand, (unsigned char)option);
  }
SWIGINTERN void vrna_fold_compound_t_hc_add_bp_nonspecific(vrna_fold_compound_t *self,unsigned int i,int d,unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS){
    vrna_hc_add_bp_nonspecific(self, i, d, (unsigned char)option);
  }
SWIGINTERN void vrna_fold_compound_t_hc_add_bp(vrna_fold_compound_t *self,unsigned int i,unsigned int j,unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS){
    vrna_hc_add_bp_strand(self, i, j, -1, -1, (unsigned char)option);
  }
SWIGINTERN void vrna_fold_compound_t_hc_add_bp_strand(vrna_fold_compound_t *self,unsigned int i,unsigned int j,int strand_i=-1,int strand_j=-1,unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS){
    vrna_hc_add_bp_strand(self, i, j, strand_i, strand_j, (unsigned char)option);
  }
SWIGINTERN int vrna_fold_compound_t_hc_add_from_db(vrna_fold_compound_t *self,char const *constraint,unsigned int options=VRNA_CONSTRAINT_DB_DEFAULT){
    return vrna_hc_add_from_db(self,constraint, options);
  }
SWIGINTERN void vrna_fold_compound_t_sc_remove(vrna_fold_compound_t *self){
    vrna_sc_remove(self);
  }
SWIGINTERN void vrna_fold_compound_t_sc_init(vrna_fold_compound_t *self){
    vrna_sc_init(self);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_up__SWIG_0(vrna_fold_compound_t *self,unsigned int i,double energy,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_sc_add_up(self, i, energy, options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_up__SWIG_1(vrna_fold_compound_t *self,std::vector< double,std::allocator< double > > constraints,unsigned int options=VRNA_OPTION_DEFAULT){
    std::vector<double>::iterator it;
    unsigned int  i = 1;
    int           ret = 1;
    it = constraints.begin();
    for(it++; it != constraints.end(); it++, i++){
      ret &= (vrna_sc_add_up(self, i, *it, options)) ? 1 : 0;
    }

    return ret;
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_bp__SWIG_0(vrna_fold_compound_t *self,unsigned int i,unsigned int j,double energy,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_sc_add_bp(self, i, j, energy, options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_bp__SWIG_1(vrna_fold_compound_t *self,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > constraints,unsigned int options=VRNA_OPTION_DEFAULT){
    int ret = 1;
    for (size_t i = 1; i < constraints.size(); i++)
      for (size_t j = i + 1; j < constraints[i].size(); j++)
        if (constraints[i][j] != 0)
          ret &= (vrna_sc_add_bp(self, i, j, constraints[i][j], options)) ? 1 : 0;

    return ret;
  }
SWIGINTERN int vrna_fold_compound_t_sc_set_bp(vrna_fold_compound_t *self,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > constraints,unsigned int options=VRNA_OPTION_DEFAULT){
    int ret = 0;

    /* make sure that the constraints matrix is large enough */
    FLT_OR_DBL **c = (FLT_OR_DBL **)vrna_alloc(sizeof(FLT_OR_DBL *) * (self->length + 1));
    for(unsigned int i = 0; i <= self->length; i++)
      c[i] = (FLT_OR_DBL *)vrna_alloc(sizeof(FLT_OR_DBL) * (self->length + 1));

    /* copy input data (missing values have value 0 */
    for(unsigned int i = 0; (i < constraints.size()) && (i <= self->length); i++)
      for(unsigned int j = i; (j < constraints[i].size()) && (j <= self->length); j++)
        c[i][j] = (FLT_OR_DBL)constraints[i][j];

    ret = vrna_sc_set_bp(self, (const FLT_OR_DBL **)c, options);

    /* cleanup */
    for(unsigned int i = 0; i <= self->length; i++)
      free(c[i]);
    free(c);

    return ret;
  }
SWIGINTERN int vrna_fold_compound_t_sc_set_up(vrna_fold_compound_t *self,std::vector< double,std::allocator< double > > constraints,unsigned int options=VRNA_OPTION_DEFAULT){
    std::vector<FLT_OR_DBL>  v;
    transform(constraints.begin(), constraints.end(), std::back_inserter(v), convert_vecdbl2vecFLR_OR_DBL);
    return vrna_sc_set_up(self, (const FLT_OR_DBL *)&v[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_set_stack__SWIG_0(vrna_fold_compound_t *self,std::vector< double,std::allocator< double > > constraints,unsigned int options=VRNA_OPTION_DEFAULT){
    std::vector<FLT_OR_DBL>  v;
    transform(constraints.begin(), constraints.end(), std::back_inserter(v), convert_vecdbl2vecFLR_OR_DBL);
    return vrna_sc_set_stack(self, (const FLT_OR_DBL *)&v[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_set_stack__SWIG_1(vrna_fold_compound_t *self,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > constraints,unsigned int options=VRNA_OPTION_DEFAULT){
    int ret = 0;

    if (self->type == VRNA_FC_TYPE_COMPARATIVE) {
      FLT_OR_DBL **c = (FLT_OR_DBL **)vrna_alloc(sizeof(FLT_OR_DBL *) * (self->n_seq + 1));

      for(unsigned int s = 0; s <= self->n_seq; s++)
        c[s] = (FLT_OR_DBL *)vrna_alloc(sizeof(FLT_OR_DBL) * (self->length + 1));

      /* copy input data (missing values have value 0 */
      for(unsigned int s = 0; (s < constraints.size()) && (s <= self->n_seq); s++)
        for(unsigned int i = 1; (i < constraints[s].size()) && (i <= self->length); i++)
          c[s][i] = (FLT_OR_DBL)constraints[s][i];

      ret = vrna_sc_set_stack_comparative(self, (const FLT_OR_DBL **)c, options);

      /* cleanup */
      for(unsigned int i = 0; i <= self->length; i++)
        free(c[i]);
      free(c);
    }

    return ret;
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_stack__SWIG_0(vrna_fold_compound_t *self,unsigned int i,double energy,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_sc_add_stack(self, i, energy, options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_stack__SWIG_1(vrna_fold_compound_t *self,std::vector< unsigned int,std::allocator< unsigned int > > i,std::vector< double,std::allocator< double > > energies,unsigned int options=VRNA_OPTION_DEFAULT){
    std::vector<FLT_OR_DBL>  v;
    transform(energies.begin(), energies.end(), std::back_inserter(v), convert_vecdbl2vecFLR_OR_DBL);
    return vrna_sc_add_stack_comparative(self, (unsigned int*)&i[0], (const FLT_OR_DBL *)&v[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_hi_motif(vrna_fold_compound_t *self,char const *seq,char const *structure,FLT_OR_DBL energy,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_sc_add_hi_motif(self, seq, structure, energy,options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_json(vrna_fold_compound_t *self,std::string json,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_json(self, json.c_str(), &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_jsonfile(vrna_fold_compound_t *self,std::string jsonfile,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_json(self, jsonfile.c_str(), &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod(vrna_fold_compound_t *self,vrna_sc_mod_param_t const params,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod(self, params, &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_m6A(vrna_fold_compound_t *self,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_m6A(self, &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_pseudouridine(vrna_fold_compound_t *self,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_pseudouridine(self, &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_inosine(vrna_fold_compound_t *self,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_inosine(self, &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_7DA(vrna_fold_compound_t *self,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_7DA(self, &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_purine(vrna_fold_compound_t *self,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_purine(self, &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_mod_dihydrouridine(vrna_fold_compound_t *self,std::vector< unsigned int,std::allocator< unsigned int > > modification_sites,unsigned int options=VRNA_SC_MOD_DEFAULT){
    modification_sites.push_back(0); /* end marker for C-implementation */
    return vrna_sc_mod_dihydrouridine(self, &modification_sites[0], options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_probing(vrna_fold_compound_t *self,vrna_probing_data_t data){
    return vrna_sc_probing(self, data);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_SHAPE_deigan(vrna_fold_compound_t *self,std::vector< double,std::allocator< double > > reactivities,double m,double b,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_sc_add_SHAPE_deigan(self, (const double *)&reactivities[0], m, b, options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_SHAPE_deigan_ali(vrna_fold_compound_t *self,std::vector< std::string,std::allocator< std::string > > shape_files,std::vector< int,std::allocator< int > > shape_file_association,double m,double b,unsigned int options=VRNA_OPTION_DEFAULT){
    std::vector<const char*>  vc;
    transform(shape_files.begin(), shape_files.end(), back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of vector */
    shape_file_association.push_back(-1); /* mark end of vector */
    return vrna_sc_add_SHAPE_deigan_ali(self, (const char **) &vc[0], (const int *) &shape_file_association[0], m, b, options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_SHAPE_zarringhalam(vrna_fold_compound_t *self,std::vector< double,std::allocator< double > > reactivities,double b,double default_value,char const *shape_conversion,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_sc_add_SHAPE_zarringhalam(self, (const double *) &reactivities[0], b, default_value, shape_conversion, options);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_SHAPE_eddy_2(vrna_fold_compound_t *self,std::vector< double,std::allocator< double > > reactivities,std::vector< double,std::allocator< double > > unpaired_data,std::vector< double,std::allocator< double > > paired_data){
    return vrna_sc_add_SHAPE_eddy_2(self, (const double *)&reactivities[0], unpaired_data.size(), (const double *)&unpaired_data[0], paired_data.size(), (const double *)&paired_data[0]);
  }
SWIGINTERN float vrna_fold_compound_t_eval_structure(vrna_fold_compound_t *self,char const *structure){
    return vrna_eval_structure(self,structure);
  }
SWIGINTERN int vrna_fold_compound_t_eval_structure_pt__SWIG_0(vrna_fold_compound_t *self,std::vector< int,std::allocator< int > > pt){
    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);
    return vrna_eval_structure_pt(self, (const short*)&vc[0]);
  }
SWIGINTERN int vrna_fold_compound_t_eval_structure_pt__SWIG_1(vrna_fold_compound_t *self,var_array< short > const &pt){
    return vrna_eval_structure_pt(self, pt.data);
  }
SWIGINTERN float vrna_fold_compound_t_eval_structure_verbose(vrna_fold_compound_t *self,char *structure,FILE *nullfile=NULL){
    return vrna_eval_structure_verbose(self, structure, nullfile);
  }
SWIGINTERN int vrna_fold_compound_t_eval_structure_pt_verbose__SWIG_0(vrna_fold_compound_t *self,std::vector< int,std::allocator< int > > pt,FILE *nullfile=NULL){
    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);
    return vrna_eval_structure_pt_verbose(self, (const short*)&vc[0], nullfile);
  }
SWIGINTERN int vrna_fold_compound_t_eval_structure_pt_verbose__SWIG_1(vrna_fold_compound_t *self,var_array< short > const &pt,FILE *nullfile=NULL){
    return vrna_eval_structure_pt_verbose(self, pt.data, nullfile);
  }
SWIGINTERN float vrna_fold_compound_t_eval_covar_structure(vrna_fold_compound_t *self,char *structure){
    return vrna_eval_covar_structure(self, structure);
  }
SWIGINTERN int vrna_fold_compound_t_eval_loop_pt__SWIG_0(vrna_fold_compound_t *self,int i,std::vector< int,std::allocator< int > > pt){
    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);
    return vrna_eval_loop_pt(self, i, (const short*)&vc[0]);
  }
SWIGINTERN int vrna_fold_compound_t_eval_loop_pt__SWIG_1(vrna_fold_compound_t *self,int i,var_array< short > const &pt){
    return vrna_eval_loop_pt(self, i, pt.data);
  }
SWIGINTERN float vrna_fold_compound_t_eval_move(vrna_fold_compound_t *self,char const *structure,int m1,int m2){
    return vrna_eval_move(self, structure, m1, m2);
  }
SWIGINTERN int vrna_fold_compound_t_eval_move_pt__SWIG_0(vrna_fold_compound_t *self,std::vector< int,std::allocator< int > > pt,int m1,int m2){
    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);
    return vrna_eval_move_pt(self, ((short*)&vc[0]), m1, m2);   /*attention here no const short* as argument*/
  }
SWIGINTERN int vrna_fold_compound_t_eval_move_pt__SWIG_1(vrna_fold_compound_t *self,var_array< short > const &pt,int m1,int m2){
    return vrna_eval_move_pt(self, pt.data, m1, m2);   /*attention here no const short* as argument*/
  }
SWIGINTERN int vrna_fold_compound_t_eval_ext_stem(vrna_fold_compound_t *self,int i,int j){
    return vrna_eval_ext_stem(self, i, j);
  }
SWIGINTERN int vrna_fold_compound_t_E_hp_loop(vrna_fold_compound_t *self,int i,int j){
    return vrna_E_hp_loop(self, i, j);
  }
SWIGINTERN int vrna_fold_compound_t_E_ext_hp_loop(vrna_fold_compound_t *self,int i,int j){
    return vrna_E_ext_hp_loop(self, i, j);
  }
SWIGINTERN int vrna_fold_compound_t_eval_ext_hp_loop(vrna_fold_compound_t *self,int i,int j){
    return vrna_eval_ext_hp_loop(self, i, j);
  }
SWIGINTERN int vrna_fold_compound_t_eval_hp_loop(vrna_fold_compound_t *self,int i,int j){
    return vrna_eval_hp_loop(self, i, j);
  }
SWIGINTERN double vrna_fold_compound_t_exp_E_hp_loop(vrna_fold_compound_t *self,int i,int j){
    return (double)vrna_exp_E_hp_loop(self, i, j);
  }
SWIGINTERN int vrna_fold_compound_t_E_int_loop(vrna_fold_compound_t *self,int i,int j){
    return vrna_E_int_loop(self, i, j);
  }
SWIGINTERN int vrna_fold_compound_t_eval_int_loop(vrna_fold_compound_t *self,int i,int j,int k,int l){
    return vrna_eval_int_loop(self, i, j, k, l);
  }
SWIGINTERN int vrna_fold_compound_t_E_ext_int_loop(vrna_fold_compound_t *self,int i,int j,int *ip,int *iq){
    return vrna_E_ext_int_loop(self, i, j, ip, iq);
  }
SWIGINTERN int vrna_fold_compound_t_E_stack(vrna_fold_compound_t *self,int i,int j){
    return vrna_E_stack(self, i, j);
  }
SWIGINTERN double vrna_fold_compound_t_exp_E_int_loop(vrna_fold_compound_t *self,int i,int j){
    return (double)vrna_exp_E_int_loop(self, i, j);
  }
SWIGINTERN double vrna_fold_compound_t_exp_E_interior_loop(vrna_fold_compound_t *self,int i,int j,int k,int l){
    return (double)vrna_exp_E_interior_loop(self, i, j, k, l);
  }
SWIGINTERN double vrna_fold_compound_t_exp_E_ext_stem(vrna_fold_compound_t *self,int i,int j){
    unsigned int type;
    int enc5, enc3;
    enc5 = enc3 = -1;
    
    type = vrna_get_ptype_md(self->sequence_encoding2[i],
                             self->sequence_encoding2[j],
                             &(self->params->model_details));

    if (i > 1)
      enc5 = self->sequence_encoding[i - 1];
    if (j < self->length)
      enc3 = self->sequence_encoding[j + 1];

    return (double)vrna_exp_E_ext_stem(type,
                                       enc5,
                                       enc3,
                                       self->exp_params);
  }
SWIGINTERN int vrna_fold_compound_t_maxmimum_matching(vrna_fold_compound_t *self){
    return vrna_maximum_matching(self);
  }
SWIGINTERN char *vrna_fold_compound_t_mfe(vrna_fold_compound_t *self,float *OUTPUT){

    char *structure = (char *)vrna_alloc(sizeof(char) * (self->length + 1));
    *OUTPUT = vrna_mfe(self, structure);
    return structure;
  }
SWIGINTERN char *vrna_fold_compound_t_mfe_dimer(vrna_fold_compound_t *self,float *OUTPUT){

    char *structure = (char*)vrna_alloc(sizeof(char) * (self->length + 1));
    *OUTPUT = vrna_mfe_dimer(self, structure);
    return structure;
  }
SWIGINTERN vrna_score_t vrna_fold_compound_t_benchmark(vrna_fold_compound_t *self,std::string gold,int fuzzy=0,unsigned int options=8U){
    vrna_score_t score;
    char *structure = (char *)vrna_alloc(sizeof(char) * (self->length + 1));
    vrna_mfe(self, structure);
    score = vrna_compare_structure(gold.c_str(), structure, fuzzy, options);
    
    free(structure);
    return score;
  }
SWIGINTERN float vrna_fold_compound_t_mfe_window(vrna_fold_compound_t *self,FILE *nullfile=NULL){
    return vrna_mfe_window(self, nullfile);
  }
SWIGINTERN float vrna_fold_compound_t_mfe_window_zscore(vrna_fold_compound_t *self,double min_z,FILE *nullfile=NULL){
    return vrna_mfe_window_zscore(self, min_z, nullfile);
  }
SWIGINTERN int vrna_fold_compound_t_zsc_filter_init(vrna_fold_compound_t *self,double min_z=-2.0,unsigned int options=VRNA_ZSCORE_SETTINGS_DEFAULT){
    return vrna_zsc_filter_init(self, min_z, options);
  }
SWIGINTERN int vrna_fold_compound_t_zsc_filter_update(vrna_fold_compound_t *self,double min_z,unsigned int options=VRNA_ZSCORE_OPTIONS_NONE){
    return vrna_zsc_filter_update(self, min_z, options);
  }
SWIGINTERN void vrna_fold_compound_t_zsc_filter_free(vrna_fold_compound_t *self){
    vrna_zsc_filter_free(self);
  }
SWIGINTERN int vrna_fold_compound_t_zsc_filter_on(vrna_fold_compound_t *self){
    return vrna_zsc_filter_on(self);
  }
SWIGINTERN double vrna_fold_compound_t_zsc_filter_threshold(vrna_fold_compound_t *self){
    return vrna_zsc_filter_threshold(self);
  }
SWIGINTERN double vrna_fold_compound_t_zsc_compute(vrna_fold_compound_t *self,unsigned int i,unsigned int j,int e){
    return vrna_zsc_compute(self, i, j, e);
  }
SWIGINTERN double vrna_fold_compound_t_zsc_compute_raw(vrna_fold_compound_t *self,unsigned int i,unsigned int j,int e,double *avg,double *sd){
    return vrna_zsc_compute_raw(self, i, j, e,avg, sd);
  }
SWIGINTERN char *vrna_fold_compound_t_backtrack__SWIG_0(vrna_fold_compound_t *self,unsigned int length,float *OUTPUT){
    char *structure = (char *)vrna_alloc(sizeof(char) * (length + 1));
    *OUTPUT = vrna_backtrack5(self, length, structure);
    return structure;
  }
SWIGINTERN char *vrna_fold_compound_t_backtrack__SWIG_1(vrna_fold_compound_t *self,float *OUTPUT){
    char *structure = (char *)vrna_alloc(sizeof(char) * (self->length + 1));
    *OUTPUT = vrna_backtrack5(self, self->length, structure);
    return structure;
  }
SWIGINTERN char *vrna_fold_compound_t_pf(vrna_fold_compound_t *self,float *OUTPUT){
    char *structure = (char *)vrna_alloc(sizeof(char) * (self->length + 1)); /*output is a structure pointer*/
    *OUTPUT= vrna_pf(self, structure);
    return structure;
  }
SWIGINTERN double vrna_fold_compound_t_mean_bp_distance(vrna_fold_compound_t *self){
    return vrna_mean_bp_distance(self);
  }
SWIGINTERN double vrna_fold_compound_t_ensemble_defect__SWIG_0(vrna_fold_compound_t *self,std::string structure,unsigned int options=8U){
    double ed;
    short int         *pt;

    pt = vrna_ptable_from_string(structure.c_str(), options);

    ed = vrna_ensemble_defect_pt(self, pt);

    free(pt);

    return ed;
  }
SWIGINTERN double vrna_fold_compound_t_ensemble_defect__SWIG_1(vrna_fold_compound_t *self,std::vector< int,std::allocator< int > > pair_table){
    std::vector<short> pt_v_short;
    transform(pair_table.begin(), pair_table.end(), back_inserter(pt_v_short), convert_vecint2vecshort);
    return vrna_ensemble_defect_pt(self, (short*)&pt_v_short[0]);
  }
SWIGINTERN double vrna_fold_compound_t_ensemble_defect__SWIG_2(vrna_fold_compound_t *self,var_array< short > const &pt){
    return vrna_ensemble_defect_pt(self, pt.data);
  }
SWIGINTERN std::vector< double,std::allocator< double > > vrna_fold_compound_t_positional_entropy(vrna_fold_compound_t *self){
    unsigned int        n;
    double              *pos_ent;
    std::vector<double> dv;

    n       = self->length;
    pos_ent = vrna_positional_entropy(self);

    if (pos_ent)
      dv.assign(pos_ent, pos_ent + (n + 1));

    return dv;
  }
SWIGINTERN double vrna_fold_compound_t_pr_structure(vrna_fold_compound_t *self,std::string structure){
    return vrna_pr_structure(self, structure.c_str());
  }
SWIGINTERN double vrna_fold_compound_t_pr_energy(vrna_fold_compound_t *self,double e){
    return vrna_pr_energy(self, e);
  }
SWIGINTERN char *vrna_fold_compound_t_pf_dimer(vrna_fold_compound_t *self,float *FA,float *FB,float *FcAB,float *FAB){
    char *structure = (char *)vrna_alloc(sizeof(char) * (self->length + 1)); /*output is a structure pointer*/
    vrna_dimer_pf_t temp = vrna_pf_dimer(self, structure);
    *FAB  = (float)temp.FAB;
    *FcAB = (float)temp.FcAB;
    *FA   = (float)temp.FA;
    *FB   = (float)temp.FB;
    return structure;
  }

SWIGINTERN int
SWIG_AsVal_bool (PyObject *obj, bool *val)
{
  int r;
  if (!PyBool_Check(obj))
    return SWIG_ERROR;
  r = PyObject_IsTrue(obj);
  if (r == -1)
    return SWIG_ERROR;
  if (val) *val = r ? true : false;
  return SWIG_OK;
}

SWIGINTERN std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > vrna_fold_compound_t_bpp(vrna_fold_compound_t *self,bool symmetric=false){
    std::vector<std::vector<double> > probabilities;
    vrna_fold_compound_t *vc = self;
    if(vc->exp_matrices && vc->exp_matrices->probs){
      int turn, i, j, *idx, n;
      FLT_OR_DBL *probs;

      n     = vc->length;
      idx   = vc->iindx;
      probs = vc->exp_matrices->probs;

      for(i = 0; i <= n; i++)
        probabilities.push_back(std::vector<double>(n + 1, 0.));

      for(i = 1; i <= n; i++) {
        for(j = i + 1; j <= n; j++) {
          probabilities[i][j] = (double)probs[idx[i] - j];
          if (symmetric)
            probabilities[j][i] = (double)probs[idx[i] - j];
        }
      }
    }

    return probabilities;
  }
SWIGINTERN std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > vrna_fold_compound_t_stack_prob(vrna_fold_compound_t *self,double cutoff=1e-5){
    std::vector<vrna_ep_t > ep_v;
    vrna_ep_t               *ptr, *plist;

    plist = vrna_stack_prob(self, cutoff);

    for (ptr = plist; ptr->i && ptr->j; ptr++) {
      vrna_ep_t pl;
      pl.i = ptr->i;
      pl.j = ptr->j;
      pl.p = ptr->p;
      pl.type = ptr->type;
      ep_v.push_back(pl);
    }

    free(plist);

    return ep_v;
  }
SWIGINTERN char *vrna_fold_compound_t_centroid(vrna_fold_compound_t *self,double *OUTPUT){
    return vrna_centroid(self, OUTPUT);
  }
SWIGINTERN char *vrna_fold_compound_t_MEA__SWIG_0(vrna_fold_compound_t *self,float *OUTPUT){
    return vrna_MEA(self, 1., OUTPUT);
  }
SWIGINTERN char *vrna_fold_compound_t_MEA__SWIG_1(vrna_fold_compound_t *self,double gamma,float *OUTPUT){
    return vrna_MEA(self, gamma, OUTPUT);
  }
SWIGINTERN char *vrna_fold_compound_t_pbacktrack__SWIG_0(vrna_fold_compound_t *self){
    return vrna_pbacktrack(self);
  }
SWIGINTERN char *vrna_fold_compound_t_pbacktrack5__SWIG_0(vrna_fold_compound_t *self,unsigned int length){
    return vrna_pbacktrack5(self, length);
  }
SWIGINTERN char *vrna_fold_compound_t_pbacktrack_sub__SWIG_0(vrna_fold_compound_t *self,unsigned int start,unsigned int end){
    return vrna_pbacktrack_sub(self, start, end);
  }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > vrna_fold_compound_t_pbacktrack__SWIG_1(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int options=VRNA_PBACKTRACK_DEFAULT){
    std::vector<std::string> str_vec;
    char  **ptr, **output;

    output = vrna_pbacktrack_num(self, num_samples, options);

    if (output) {
      for (ptr = output; *ptr != NULL; ptr++) {
        str_vec.push_back(std::string(*ptr));
        free(*ptr);
      }

      free(output);
    }

    return str_vec;
  }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > vrna_fold_compound_t_pbacktrack5__SWIG_1(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int length,unsigned int options=VRNA_PBACKTRACK_DEFAULT){
    std::vector<std::string> str_vec;
    char  **ptr, **output;

    output = vrna_pbacktrack5_num(self, num_samples, length, options);

    if (output) {
      for (ptr = output; *ptr != NULL; ptr++) {
        str_vec.push_back(std::string(*ptr));
        free(*ptr);
      }

      free(output);
    }

    return str_vec;
  }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > vrna_fold_compound_t_pbacktrack_sub__SWIG_1(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int start,unsigned int end,unsigned int options=VRNA_PBACKTRACK_DEFAULT){
    std::vector<std::string> str_vec;
    char  **ptr, **output;

    output = vrna_pbacktrack_sub_num(self, num_samples, start, end, options);

    if (output) {
      for (ptr = output; *ptr != NULL; ptr++) {
        str_vec.push_back(std::string(*ptr));
        free(*ptr);
      }

      free(output);
    }

    return str_vec;
  }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > vrna_fold_compound_t_pbacktrack__SWIG_2(vrna_fold_compound_t *self,unsigned int num_samples,vrna_pbacktrack_mem_t *nr_memory,unsigned int options=VRNA_PBACKTRACK_DEFAULT){
    std::vector<std::string> str_vec;

    char **ptr, **output = vrna_pbacktrack_resume(self,
                                                  num_samples,
                                                  nr_memory,
                                                  options);

    if (output) {
      for (ptr = output; *ptr != NULL; ptr++) {
        str_vec.push_back(std::string(*ptr));
        free(*ptr);
      }

      free(output);
    }

    return str_vec;
  }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > vrna_fold_compound_t_pbacktrack5__SWIG_2(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int length,vrna_pbacktrack_mem_t *nr_memory,unsigned int options=VRNA_PBACKTRACK_DEFAULT){
    std::vector<std::string> str_vec;

    char **ptr, **output;
    
    output = vrna_pbacktrack5_resume(self,
                                     num_samples,
                                     length,
                                     nr_memory,
                                     options);

    if (output) {
      for (ptr = output; *ptr != NULL; ptr++) {
        str_vec.push_back(std::string(*ptr));
        free(*ptr);
      }

      free(output);
    }

    return str_vec;
  }
SWIGINTERN std::vector< std::string,std::allocator< std::string > > vrna_fold_compound_t_pbacktrack_sub__SWIG_2(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int start,unsigned int end,vrna_pbacktrack_mem_t *nr_memory,unsigned int options=VRNA_PBACKTRACK_DEFAULT){
    std::vector<std::string> str_vec;

    char **ptr, **output;
    
    output = vrna_pbacktrack_sub_resume(self,
                                        num_samples,
                                        start,
                                        end,
                                        nr_memory,
                                        options);

    if (output) {
      for (ptr = output; *ptr != NULL; ptr++) {
        str_vec.push_back(std::string(*ptr));
        free(*ptr);
      }

      free(output);
    }

    return str_vec;
  }
SWIGINTERN std::vector< subopt_solution,std::allocator< subopt_solution > > vrna_fold_compound_t_subopt(vrna_fold_compound_t *self,int delta,int sorted=1,FILE *nullfile=NULL){
    std::vector<subopt_solution> ret;
    SOLUTION *sol = vrna_subopt(self, delta, sorted, nullfile);
    if (sol)
      for(int i = 0; sol[i].structure != NULL; i++){
        subopt_solution a{ sol[i].energy, sol[i].structure};
        ret.push_back(a);
        free(sol[i].structure);
      }

    free(sol);
    /* The memory occupied by the individual structures will be free'd automatically
       by swig, when the vector is destroyed
    */
    return ret;
  }
SWIGINTERN std::vector< subopt_solution,std::allocator< subopt_solution > > vrna_fold_compound_t_subopt_zuker(vrna_fold_compound_t *self){
    std::vector<subopt_solution> ret;
    SOLUTION *sol = vrna_subopt_zuker(self);
    if (sol)
      for(int i = 0; sol[i].structure != NULL; i++){
        subopt_solution a{ sol[i].energy, sol[i].structure};
        ret.push_back(a);
        free(sol[i].structure);
      }

    free(sol);
    /* The memory occupied by the individual structures will be free'd automatically
       by swig, when the vector is destroyed
    */
    return ret;
  }
SWIGINTERN int vrna_fold_compound_t_sequence_add(vrna_fold_compound_t *self,std::string sequence,unsigned int options=VRNA_SEQUENCE_RNA){
    return vrna_sequence_add(self,
                             sequence.c_str(),
                             options);
  }
SWIGINTERN int vrna_fold_compound_t_sequence_remove(vrna_fold_compound_t *self,unsigned int i){
    return vrna_sequence_remove(self,
                                i);
  }
SWIGINTERN void vrna_fold_compound_t_sequence_remove_all(vrna_fold_compound_t *self){
    vrna_sequence_remove_all(self);
  }
SWIGINTERN void vrna_fold_compound_t_sequence_prepare(vrna_fold_compound_t *self){
    vrna_sequence_prepare(self);
  }
SWIGINTERN void vrna_fold_compound_t_ud_add_motif(vrna_fold_compound_t *self,std::string motif,double motif_en,std::string name="",unsigned int options=VRNA_UNSTRUCTURED_DOMAIN_ALL_LOOPS){
    if (name == "")
      vrna_ud_add_motif(self, motif.c_str(), motif_en, NULL, options);
    else
      vrna_ud_add_motif(self, motif.c_str(), motif_en, name.c_str(), options);
  }
SWIGINTERN void vrna_fold_compound_t_ud_remove(vrna_fold_compound_t *self){
    vrna_ud_remove(self);
  }
SWIGINTERN int vrna_fold_compound_t_commands_apply(vrna_fold_compound_t *self,vrna_command_s *commands,unsigned int options=VRNA_CMD_PARSE_DEFAULTS){
    return vrna_commands_apply(self,
                               commands,
                               options);
  }
SWIGINTERN int vrna_fold_compound_t_file_commands_apply(vrna_fold_compound_t *self,std::string filename,unsigned int options=VRNA_CMD_PARSE_DEFAULTS){
    return vrna_file_commands_apply(self,
                                    filename.c_str(),
                                    options);
  }
SWIGINTERN std::vector< unsigned int,std::allocator< unsigned int > > vrna_fold_compound_t_rotational_symmetry_db(vrna_fold_compound_t *self,std::string structure){
    std::vector<unsigned int> positions;
    unsigned int i, r, *pos;

    r = vrna_rotational_symmetry_db_pos(self, structure.c_str(), &pos);

    if (r)
      for (i = 0; i < r; i++)
        positions.push_back(pos[i]);

    free(pos);

    return positions;
  }
SWIGINTERN var_array< vrna_move_t > *vrna_fold_compound_t_neighbors(vrna_fold_compound_t *self,var_array< short > &pt,unsigned int options=(4|8)){
    var_array<vrna_move_t>  *v;
    vrna_move_t             *move_t, *ptr;

    v      = NULL;
    move_t = vrna_neighbors(self, pt.data, options);

    if (move_t) {
      /* get size of new and changed moves */
      size_t n = 0;
      for (ptr = move_t; ptr->pos_5 != 0; ptr++, n++);
      v = var_array_new(n, move_t, VAR_ARRAY_LINEAR | VAR_ARRAY_OWNED);
    }

    return v;
  }
SWIGINTERN var_array< vrna_move_t > *vrna_fold_compound_t_move_neighbor_diff__SWIG_0(vrna_fold_compound_t *self,var_array< short > &pt,vrna_move_t move,var_array< vrna_move_t > *&invalid_moves,unsigned int options=(4|8)){
    var_array<vrna_move_t> *v; /* fill vector with returned vrna_move_t */
    vrna_move_t *move_t, *mv_invalid, *ptr;

    mv_invalid  = NULL;
    v           = NULL;
    move_t = vrna_move_neighbor_diff(self,
                                     pt.data,
                                     move,
                                     &mv_invalid,
                                     options);

    if (mv_invalid) {
      /* get size of invalid moves */
      size_t n = 0;
      for (ptr = mv_invalid; ptr->pos_5 != 0; ptr++, n++);
      invalid_moves = var_array_new(n, mv_invalid, VAR_ARRAY_LINEAR | VAR_ARRAY_OWNED);
    }

    if (move_t) {
      /* get size of new and changed moves */
      size_t n = 0;
      for (ptr = move_t; ptr->pos_5 != 0; ptr++, n++);
      v = var_array_new(n, move_t, VAR_ARRAY_LINEAR | VAR_ARRAY_OWNED);
    }

    return v;
  }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > vrna_fold_compound_t_path__SWIG_0(vrna_fold_compound_t *self,std::vector< int,std::allocator< int > > &pt,unsigned int steps,unsigned int options=VRNA_PATH_DEFAULT){
    int i;
    std::vector<short>::iterator it;
    std::vector<vrna_move_t>  v; /* fill vector with returned vrna_move_t */
    vrna_move_t *move_t, *ptr;
    std::vector<short> vc;

    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);

    move_t = ptr = vrna_path(self, (short*)&vc[0], steps, options);
    
    if (ptr)
      while ((ptr->pos_5 != 0) && (ptr->pos_3 != 0)) {
        vrna_move_t m;
        m = vrna_move_init(ptr->pos_5, ptr->pos_3);
        v.push_back(m);
        ptr++;
      }

    /* copy over the values from vc to pt */
    for (i = 0, it = vc.begin(); it != vc.end(); ++it, i++)
      pt[i] = *it;

    free(move_t);
    return v;
  }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > vrna_fold_compound_t_path__SWIG_1(vrna_fold_compound_t *self,var_array< short > &pt,unsigned int steps,unsigned int options=VRNA_PATH_DEFAULT){
    int i;
    std::vector<vrna_move_t>  v; /* fill vector with returned vrna_move_t */
    vrna_move_t *move_t, *ptr;

    move_t = ptr = vrna_path(self, pt.data, steps, options);
    
    if (ptr)
      while ((ptr->pos_5 != 0) && (ptr->pos_3 != 0)) {
        vrna_move_t m;
        m = vrna_move_init(ptr->pos_5, ptr->pos_3);
        v.push_back(m);
        ptr++;
      }

    free(move_t);
    return v;
  }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > vrna_fold_compound_t_path_gradient__SWIG_0(vrna_fold_compound_t *self,std::vector< int,std::allocator< int > > &pt,unsigned int options=VRNA_PATH_DEFAULT){
    int i;
    std::vector<short>::iterator it;
    std::vector<vrna_move_t>  v; /* fill vector with returned vrna_move_t */
    vrna_move_t *move_t, *ptr;

    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);

    move_t = ptr = vrna_path_gradient(self, (short*)&vc[0], options);

    if (ptr)
      while ((ptr->pos_5 != 0) && (ptr->pos_3 != 0)) {
        vrna_move_t m;
        m = vrna_move_init(ptr->pos_5, ptr->pos_3);
        v.push_back(m);
        ptr++;
      }

    /* copy over the values from vc to pt */
    for (i = 0, it = vc.begin(); it != vc.end(); ++it, i++)
      pt[i] = *it;

    free(move_t);
    return v;
  }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > vrna_fold_compound_t_path_gradient__SWIG_1(vrna_fold_compound_t *self,var_array< short > &pt,unsigned int options=VRNA_PATH_DEFAULT){
    int i;
    std::vector<vrna_move_t>  v; /* fill vector with returned vrna_move_t */
    vrna_move_t *move_t, *ptr;

    move_t = ptr = vrna_path_gradient(self, pt.data, options);

    if (ptr)
      while ((ptr->pos_5 != 0) && (ptr->pos_3 != 0)) {
        vrna_move_t m;
        m = vrna_move_init(ptr->pos_5, ptr->pos_3);
        v.push_back(m);
        ptr++;
      }

    free(move_t);
    return v;
  }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > vrna_fold_compound_t_path_random__SWIG_0(vrna_fold_compound_t *self,std::vector< int,std::allocator< int > > &pt,unsigned int steps,unsigned int options=VRNA_PATH_DEFAULT){
    int i;
    std::vector<short>::iterator it;
    std::vector<vrna_move_t>  v; /* fill vector with returned vrna_move_t */
    vrna_move_t *move_t, *ptr;

    std::vector<short> vc;
    transform(pt.begin(), pt.end(), back_inserter(vc), convert_vecint2vecshort);

    move_t = ptr = vrna_path_random(self, (short*)&vc[0], steps, options);

    if (ptr)
      while ((ptr->pos_5 != 0) && (ptr->pos_3 != 0)) {
        vrna_move_t m;
        m = vrna_move_init(ptr->pos_5, ptr->pos_3);
        v.push_back(m);
        ptr++;
      }

    /* copy over the values from vc to pt */
    for (i = 0, it = vc.begin(); it != vc.end(); ++it, i++)
      pt[i] = *it;

    free(move_t);
    return v;
  }
SWIGINTERN std::vector< vrna_move_t,std::allocator< vrna_move_t > > vrna_fold_compound_t_path_random__SWIG_1(vrna_fold_compound_t *self,var_array< short > &pt,unsigned int steps,unsigned int options=VRNA_PATH_DEFAULT){
    int i;
    std::vector<vrna_move_t>  v; /* fill vector with returned vrna_move_t */
    vrna_move_t *move_t, *ptr;

    move_t = ptr = vrna_path_random(self, pt.data, steps, options);

    if (ptr)
      while ((ptr->pos_5 != 0) && (ptr->pos_3 != 0)) {
        vrna_move_t m;
        m = vrna_move_init(ptr->pos_5, ptr->pos_3);
        v.push_back(m);
        ptr++;
      }

    free(move_t);
    return v;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_path_findpath_saddle(vrna_fold_compound_t *self,std::string s1,std::string s2,int width=1,int maxE=INT_MAX){
    PyObject *E_obj = Py_None;

    int E = vrna_path_findpath_saddle_ub(self, s1.c_str(), s2.c_str(), width, maxE);

    if (E < maxE)
      E_obj = Py_BuildValue("i", E);
    else
      Py_INCREF(Py_None); /* increase reference count for Py_None */

    return E_obj;
  }
SWIGINTERN std::vector< vrna_path_t,std::allocator< vrna_path_t > > vrna_fold_compound_t_path_findpath(vrna_fold_compound_t *self,std::string s1,std::string s2,int width=1,int maxE=INT_MAX-1){
      std::vector<vrna_path_t>  v; /* fill vector with returned vrna_path_t*/
      vrna_path_t *path_t, *ptr;
      path_t = ptr = vrna_path_findpath_ub(self, s1.c_str(), s2.c_str(), width, maxE);

      if (ptr) {
        while (ptr->s != NULL)
        {
            vrna_path_t p;

            p.type  = VRNA_PATH_TYPE_DOT_BRACKET;
            p.en    = ptr->en;
            p.s     = ptr->s;

            v.push_back(p);
            ptr++;
        }
        free(path_t);
      }
      return v;
  }
SWIGINTERN std::vector< vrna_path_t,std::allocator< vrna_path_t > > vrna_fold_compound_t_path_direct(vrna_fold_compound_t *self,std::string s1,std::string s2,int maxE=INT_MAX-1,vrna_path_options_s *options=NULL){
      std::vector<vrna_path_t>  v; /* fill vector with returned vrna_path_t*/
      vrna_path_t *path_t, *ptr;
      path_t = ptr = vrna_path_direct_ub(self, s1.c_str(), s2.c_str(), maxE, options);

      if (ptr) {
        if (ptr->type == VRNA_PATH_TYPE_DOT_BRACKET)
          for (; ptr->s != NULL; ptr++) {
            vrna_path_t p;
            p.type = ptr->type;
            p.en   = ptr->en;
            p.s    = ptr->s;
            p.move = ptr->move;
            v.push_back(p);
          }
        else if (ptr->type == VRNA_PATH_TYPE_MOVES)
          for (; ptr->move.pos_5 != 0; ptr++) {
            vrna_path_t p;
            p.type = ptr->type;
            p.en   = ptr->en;
            p.s    = ptr->s;
            p.move = ptr->move;
            v.push_back(p);
          }
      }

      free(path_t);

      return v;
  }
SWIGINTERN std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > vrna_fold_compound_t_heat_capacity(vrna_fold_compound_t *self,float T_min=0.,float T_max=100.,float T_increment=1.,unsigned int mpoints=2U){
    vrna_heat_capacity_t              *result_c;
    std::vector<heat_capacity_result> result;

    result_c = vrna_heat_capacity(self, T_min, T_max, T_increment, mpoints);

    if (result_c) {
      for (size_t i = 0; result_c[i].temperature >= T_min; i++) {
        heat_capacity_result r;
        r.temperature = result_c[i].temperature;
        r.heat_capacity = result_c[i].heat_capacity;
        result.push_back(r);
      }
    }

    free(result_c);

    return result;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_add_auxdata(vrna_fold_compound_t *self,PyObject *data,PyObject *PyFuncOrNone=Py_None){
    fc_add_pydata(self, data, PyFuncOrNone);
    Py_RETURN_NONE;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_add_callback(vrna_fold_compound_t *self,PyObject *PyFunc){
    fc_add_pycallback(self, PyFunc);
    Py_RETURN_NONE;
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_data(vrna_fold_compound_t *self,PyObject *data,PyObject *callback=Py_None){
    return sc_add_pydata(self, data, callback);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_f(vrna_fold_compound_t *self,PyObject *callback){
    return sc_add_f_pycallback(self, callback);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_bt(vrna_fold_compound_t *self,PyObject *PyFunc){
    return sc_add_bt_pycallback(self, PyFunc);
  }
SWIGINTERN int vrna_fold_compound_t_sc_add_exp_f(vrna_fold_compound_t *self,PyObject *PyFunc){
    return sc_add_exp_f_pycallback(self, PyFunc);
  }
SWIGINTERN PyObject *vrna_fold_compound_t_ud_set_data(vrna_fold_compound_t *self,PyObject *data,PyObject *free_cb=Py_None){
    ud_set_pydata(self, data, free_cb);
    Py_RETURN_NONE;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_ud_set_prod_rule_cb(vrna_fold_compound_t *self,PyObject *prod_cb,PyObject *eval_cb){
    if (!PyCallable_Check(prod_cb)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      Py_RETURN_NONE;
    } else if (!PyCallable_Check(eval_cb)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      Py_RETURN_NONE;
    }
    ud_set_prod_cb(self, prod_cb, eval_cb);
    Py_RETURN_NONE;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_ud_set_exp_prod_rule_cb(vrna_fold_compound_t *self,PyObject *prod_cb,PyObject *eval_cb){
    if (!PyCallable_Check(prod_cb)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      Py_RETURN_NONE;
    } else if (!PyCallable_Check(eval_cb)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      Py_RETURN_NONE;
    }
    ud_set_exp_prod_cb(self, prod_cb, eval_cb);
    Py_RETURN_NONE;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_ud_set_prob_cb(vrna_fold_compound_t *self,PyObject *setter_cb,PyObject *getter_cb){
    if (!PyCallable_Check(setter_cb)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      Py_RETURN_NONE;
    } else if (!PyCallable_Check(getter_cb)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      Py_RETURN_NONE;
    }
    ud_set_prob_cb(self, setter_cb, getter_cb);
    Py_RETURN_NONE;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_subopt_cb(vrna_fold_compound_t *self,int delta,PyObject *PyFunc,PyObject *data=Py_None){

    python_subopt_callback_t *cb = bind_subopt_callback(PyFunc, data);
    vrna_subopt_cb(self, delta, &python_wrap_subopt_cb, (void *)cb);
    release_subopt_callback(cb);
    Py_RETURN_NONE;
  }
SWIGINTERN unsigned int vrna_fold_compound_t_pbacktrack5__SWIG_3(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int length,PyObject *PyFunc,PyObject *data=Py_None,unsigned int options=0){
    unsigned int i;
    python_bs_callback_t *cb = bind_bs_callback(PyFunc, data);

    i = vrna_pbacktrack5_cb(self,
                            num_samples,
                            length,
                            &python_wrap_bs_cb,
                            (void *)cb,
                            options);

    release_bs_callback(cb);

    return i;
  }
SWIGINTERN unsigned int vrna_fold_compound_t_pbacktrack__SWIG_3(vrna_fold_compound_t *self,unsigned int num_samples,PyObject *PyFunc,PyObject *data=Py_None,unsigned int options=0){
    unsigned int i;
    python_bs_callback_t *cb = bind_bs_callback(PyFunc, data);

    i = vrna_pbacktrack_cb(self,
                           num_samples,
                           &python_wrap_bs_cb,
                           (void *)cb,
                           options);

    release_bs_callback(cb);

    return i;
  }
SWIGINTERN unsigned int vrna_fold_compound_t_pbacktrack_sub__SWIG_3(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int start,unsigned int end,PyObject *PyFunc,PyObject *data=Py_None,unsigned int options=0){
    unsigned int i;
    python_bs_callback_t *cb = bind_bs_callback(PyFunc, data);

    i = vrna_pbacktrack_sub_cb(self,
                               num_samples,
                               start,
                               end,
                               &python_wrap_bs_cb,
                               (void *)cb,
                               options);

    release_bs_callback(cb);

    return i;
  }
SWIGINTERN unsigned int vrna_fold_compound_t_pbacktrack__SWIG_4(vrna_fold_compound_t *self,unsigned int num_samples,PyObject *PyFunc,PyObject *data,vrna_pbacktrack_mem_t *nr_memory,unsigned int options=0){
    unsigned int i;
    python_bs_callback_t *cb = bind_bs_callback(PyFunc, data);

    i = vrna_pbacktrack_resume_cb(self,
                                  num_samples,
                                  &python_wrap_bs_cb,
                                  (void *)cb,
                                  nr_memory,
                                  options);

    release_bs_callback(cb);

    return i;
  }
SWIGINTERN unsigned int vrna_fold_compound_t_pbacktrack5__SWIG_4(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int length,PyObject *PyFunc,PyObject *data,vrna_pbacktrack_mem_t *nr_memory,unsigned int options=0){
    unsigned int i;
    python_bs_callback_t *cb = bind_bs_callback(PyFunc, data);

    i = vrna_pbacktrack5_resume_cb(self,
                                   num_samples,
                                   length,
                                   &python_wrap_bs_cb,
                                   (void *)cb,
                                   nr_memory,
                                   options);

    release_bs_callback(cb);

    return i;
  }
SWIGINTERN unsigned int vrna_fold_compound_t_pbacktrack_sub__SWIG_4(vrna_fold_compound_t *self,unsigned int num_samples,unsigned int start,unsigned int end,PyObject *PyFunc,PyObject *data,vrna_pbacktrack_mem_t *nr_memory,unsigned int options=0){
    unsigned int i;
    python_bs_callback_t *cb = bind_bs_callback(PyFunc, data);

    i = vrna_pbacktrack_sub_resume_cb(self,
                                      num_samples,
                                      start,
                                      end,
                                      &python_wrap_bs_cb,
                                      (void *)cb,
                                      nr_memory,
                                      options);

    release_bs_callback(cb);

    return i;
  }
SWIGINTERN float vrna_fold_compound_t_mfe_window_cb(vrna_fold_compound_t *self,PyObject *PyFunc,PyObject *data=Py_None){
    float en;
    python_mfe_window_callback_t *cb = bind_mfe_window_callback(PyFunc, data);
    en = vrna_mfe_window_cb(self, &python_wrap_mfe_window_cb, (void *)cb);
    release_mfe_window_callback(cb);
    return en;
  }
SWIGINTERN float vrna_fold_compound_t_mfe_window_zscore_cb(vrna_fold_compound_t *self,double min_z,PyObject *PyFunc,PyObject *data=Py_None){
    float en;
    python_mfe_window_callback_t *cb = bind_mfe_window_callback(PyFunc, data);
    en = vrna_mfe_window_zscore_cb(self, min_z, &python_wrap_mfe_window_zscore_cb, (void *)cb);
    release_mfe_window_callback(cb);
    return en;
  }
SWIGINTERN int vrna_fold_compound_t_probs_window(vrna_fold_compound_t *self,int ulength,unsigned int options,PyObject *PyFunc,PyObject *data=Py_None){
    python_pf_window_callback_t *cb = bind_pf_window_callback(PyFunc, data);
    int r = vrna_probs_window(self, ulength, options, &python_wrap_pf_window_cb, (void *)cb);
    release_pf_window_callback(cb);
    return r;
  }
SWIGINTERN PyObject *vrna_fold_compound_t_heat_capacity_cb(vrna_fold_compound_t *self,float T_min,float T_max,float T_increment,unsigned int mpoints,PyObject *PyFunc,PyObject *data=Py_None){
    python_heat_capacity_callback_t *cb = bind_heat_capacity_callback(PyFunc, data);
    vrna_heat_capacity_cb(self, T_min, T_max, T_increment, mpoints, &python_wrap_heat_capacity_cb, (void *)cb);
    release_heat_capacity_callback(cb);
    Py_RETURN_NONE;
  }
SWIGINTERN int vrna_fold_compound_t_move_neighbor_diff__SWIG_1(vrna_fold_compound_t *self,var_array< short > &pt,vrna_move_t *move,PyObject *PyFunc,PyObject *data=Py_None,unsigned int options=(4|8)){
    int                 ret = 0;
    pycallback_simple_t *cb = bind_simple_callback(PyFunc,
                                                   data);

    ret = vrna_move_neighbor_diff_cb(self,
                                     pt.data,
                                     *move,
                                     &python_wrap_move_update_cb,
                                     (void *)cb,
                                     options);

    release_simple_callback(cb);
    return ret;
  }
SWIGINTERN unsigned int vrna_fold_compound_t_sc_multi_cb_add(vrna_fold_compound_t *self,PyObject *f,PyObject *f_exp=Py_None,PyObject *data=Py_None,PyObject *data_prepare=Py_None,PyObject *data_free=Py_None,unsigned int decomp_type=0){
    return sc_multi_cb_add_pycallback(self,
                                      f,
                                      f_exp,
                                      data,
                                      data_prepare,
                                      data_free,
                                      decomp_type);
  }
SWIGINTERN vrna_fold_compound_t *new_vrna_fold_compound_t__SWIG_0(char const *sequence,vrna_md_t *md=NULL,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_fold_compound(sequence, md, options);
  }
SWIGINTERN vrna_fold_compound_t *new_vrna_fold_compound_t__SWIG_1(std::vector< std::string,std::allocator< std::string > > alignment,vrna_md_t *md=NULL,unsigned int options=VRNA_OPTION_DEFAULT){
    std::vector<const char*>  vc;
    transform(alignment.begin(), alignment.end(), back_inserter(vc), convert_vecstring2veccharcp);
    vc.push_back(NULL); /* mark end of sequences */
    return vrna_fold_compound_comparative((const char **)&vc[0], md, options);
  }
SWIGINTERN vrna_fold_compound_t *new_vrna_fold_compound_t__SWIG_2(char const *sequence,char *s1,char *s2,vrna_md_t *md=NULL,unsigned int options=VRNA_OPTION_DEFAULT){
    return vrna_fold_compound_TwoD(sequence,s1,s2, md, options);
  }
SWIGINTERN void delete_vrna_fold_compound_t(vrna_fold_compound_t *self){
    vrna_fold_compound_free(self);
  }
SWIGINTERN std::string vrna_fold_compound_t___str__(vrna_fold_compound_t *self){
    std::ostringstream out;

    out << "{ ";

    if (self->type == VRNA_FC_TYPE_SINGLE) {
      out << "sequence: \"" << self->sequence << "\"";
    } else {
      out << "sequences: (" << "\"" << self->sequences[0] << "\"";
      for (size_t i = 1; i < self->n_seq; i++)
        out << ", \"" << self->sequences[i] << "\"";
      out << ")";
    }
    out << ", length: " << self->length;
    out << ", strands: " << self->strands;
    out << " }";

    return std::string(out.str());
  }

  var_array<unsigned int> *
  vrna_fold_compound_t_strand_number_get(vrna_fold_compound_t *fc)
  {
    return var_array_new(fc->length,
                         fc->strand_number,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  std::string
  vrna_fold_compound_t_sequence_get(vrna_fold_compound_t *fc)
  {
    return std::string(fc->sequence);
  }

  var_array<unsigned int> *
  vrna_fold_compound_t_strand_order_get(vrna_fold_compound_t *fc)
  {
    return var_array_new(fc->strands,
                         fc->strand_order,
                         VAR_ARRAY_LINEAR);
  }

  var_array<unsigned int> *
  vrna_fold_compound_t_strand_start_get(vrna_fold_compound_t *fc)
  {
    return var_array_new(fc->strands,
                         fc->strand_start,
                         VAR_ARRAY_LINEAR);
  }

  var_array<unsigned int> *
  vrna_fold_compound_t_strand_end_get(vrna_fold_compound_t *fc)
  {
    return var_array_new(fc->strands,
                         fc->strand_end,
                         VAR_ARRAY_LINEAR);
  }

  var_array<int> *
  vrna_fold_compound_t_iindx_get(vrna_fold_compound_t *fc)
  {
    return var_array_new(fc->length,
                         fc->iindx,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<int> *
  vrna_fold_compound_t_jindx_get(vrna_fold_compound_t *fc)
  {
    if (fc->type == VRNA_FC_TYPE_SINGLE)
      return var_array_new(fc->length,
                           fc->jindx,
                           VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);

    return NULL;
  }

  var_array<short> *
  vrna_fold_compound_t_sequence_encoding_get(vrna_fold_compound_t *fc)
  {
    if (fc->type == VRNA_FC_TYPE_SINGLE)
      return var_array_new(fc->length + 1,
                           fc->sequence_encoding,
                           VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);

    return NULL;
  }

  var_array<short> *
  vrna_fold_compound_t_sequence_encoding2_get(vrna_fold_compound_t *fc)
  {
    return var_array_new(fc->length + 1,
                         fc->sequence_encoding2,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

SWIGINTERN vrna_mx_mfe_t *new_vrna_mx_mfe_t(){ return NULL; }
SWIGINTERN void delete_vrna_mx_mfe_t(vrna_mx_mfe_t *self){}

  var_array<int> *
  vrna_mx_mfe_t_f5_get(vrna_mx_mfe_t *mx)
  {
    return var_array_new(mx->length,
                         mx->f5,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<int> *
  vrna_mx_mfe_t_f3_get(vrna_mx_mfe_t *mx)
  {
    return var_array_new(mx->length,
                         mx->f3,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<int> *
  vrna_mx_mfe_t_c_get(vrna_mx_mfe_t *mx)
  {
    return var_array_new(mx->length,
                         mx->c,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<int> *
  vrna_mx_mfe_t_fML_get(vrna_mx_mfe_t *mx)
  {
    return var_array_new(mx->length,
                         mx->fML,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<int> *
  vrna_mx_mfe_t_fM1_get(vrna_mx_mfe_t *mx)
  {
    return var_array_new(mx->length,
                         mx->fM1,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<int> *
  vrna_mx_mfe_t_fM2_get(vrna_mx_mfe_t *mx)
  {
    return var_array_new(mx->length,
                         mx->fM2,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  const int
  vrna_mx_mfe_t_Fc_get(vrna_mx_mfe_t *mx)
  {
    return mx->Fc;
  }

  const int
  vrna_mx_mfe_t_FcH_get(vrna_mx_mfe_t *mx)
  {
    return mx->FcH;
  }

  const int
  vrna_mx_mfe_t_FcI_get(vrna_mx_mfe_t *mx)
  {
    return mx->FcI;
  }

  const int
  vrna_mx_mfe_t_FcM_get(vrna_mx_mfe_t *mx)
  {
    return mx->FcM;
  }

SWIGINTERN vrna_mx_pf_t *new_vrna_mx_pf_t(){ return NULL; }
SWIGINTERN void delete_vrna_mx_pf_t(vrna_mx_pf_t *self){}

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_scale_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->scale,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_expMLbase_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->expMLbase,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_qm1_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->qm1,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_q_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->q,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_qb_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->qb,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_qm_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->qm,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_probs_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->probs,
                         VAR_ARRAY_TRI | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_q1k_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->q1k,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_qln_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->qln,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  var_array<FLT_OR_DBL> *
  vrna_mx_pf_t_qm2_get(vrna_mx_pf_t *mx)
  {
    return var_array_new(mx->length,
                         mx->qm2,
                         VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED);
  }

  const FLT_OR_DBL
  vrna_mx_pf_t_qo_get(vrna_mx_pf_t *mx)
  {
    return mx->qo;
  }

  const FLT_OR_DBL
  vrna_mx_pf_t_qho_get(vrna_mx_pf_t *mx)
  {
    return mx->qho;
  }

  const FLT_OR_DBL
  vrna_mx_pf_t_qio_get(vrna_mx_pf_t *mx)
  {
    return mx->qio;
  }

  const FLT_OR_DBL
  vrna_mx_pf_t_qmo_get(vrna_mx_pf_t *mx)
  {
    return mx->qmo;
  }


  /* tokenize string and create vector of doubles */
  PyObject *
  vrna_string_to_double_tuple(std::string s)
  {
    vrna_array(double)  c_vs;
    PyObject            *py_data;

    py_data = Py_None;
    c_vs    = vrna_str_to_dbl_array(s.c_str(), "\n", 0);

    if (c_vs) {
      py_data = PyTuple_New(vrna_array_size(c_vs));

      for (size_t i = 0; i < vrna_array_size(c_vs); i++) {
        PyObject *d = PyFloat_FromDouble( c_vs[i]);
        PyTuple_SET_ITEM(py_data, i, d);
      }
    }

    vrna_array_free(c_vs);

    return py_data;
  }


 extern const double  my_probing_data_prior_probing_1M7_paired[];


 extern const double  my_probing_data_prior_probing_1M7_unpaired[];


 extern const double  my_probing_data_prior_probing_DMS_paired[];


 extern const double  my_probing_data_prior_probing_DMS_unpaired[];

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_new_intP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  int *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_intP", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intP" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (int *)new_intP(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_intP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:delete_intP", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intP" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  delete_intP(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intP_getitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intP_getitem", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intP_getitem" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intP_getitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (int)intP_getitem(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intP_setitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  size_t arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:intP_setitem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intP_setitem" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intP_setitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intP_setitem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  intP_setitem(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_intArray(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  intArray *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_intArray", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intArray" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (intArray *)new_intArray(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intArray, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_intArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  intArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intArray" "', argument " "1"" of type '" "intArray *""'"); 
  }
  arg1 = reinterpret_cast< intArray * >(argp1);
  delete_intArray(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intArray___getitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  intArray *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"index",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:intArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___getitem__" "', argument " "1"" of type '" "intArray *""'"); 
  }
  arg1 = reinterpret_cast< intArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___getitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (int)intArray___getitem__(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intArray___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  intArray *arg1 = 0 ;
  size_t arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:intArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray___setitem__" "', argument " "1"" of type '" "intArray *""'"); 
  }
  arg1 = reinterpret_cast< intArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intArray___setitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intArray___setitem__" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  intArray___setitem__(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intArray_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  intArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_intArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_cast" "', argument " "1"" of type '" "intArray *""'"); 
  }
  arg1 = reinterpret_cast< intArray * >(argp1);
  result = (int *)intArray_cast(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intArray_frompointer(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"t",  NULL 
  };
  intArray *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:intArray_frompointer", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intArray_frompointer" "', argument " "1"" of type '" "int *""'"); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  result = (intArray *)intArray_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *intArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_intArray, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *intArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_floatP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  float *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_floatP", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatP" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (float *)new_floatP(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_floatP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:delete_floatP", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatP" "', argument " "1"" of type '" "float *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  delete_floatP(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatP_getitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:floatP_getitem", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatP_getitem" "', argument " "1"" of type '" "float *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatP_getitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float)floatP_getitem(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatP_setitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  size_t arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:floatP_setitem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatP_setitem" "', argument " "1"" of type '" "float *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatP_setitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatP_setitem" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  floatP_setitem(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_floatArray(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  floatArray *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_floatArray", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_floatArray" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (floatArray *)new_floatArray(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatArray, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_floatArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  floatArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_floatArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_floatArray" "', argument " "1"" of type '" "floatArray *""'"); 
  }
  arg1 = reinterpret_cast< floatArray * >(argp1);
  delete_floatArray(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatArray___getitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  floatArray *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"index",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:floatArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_floatArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray___getitem__" "', argument " "1"" of type '" "floatArray *""'"); 
  }
  arg1 = reinterpret_cast< floatArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatArray___getitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float)floatArray___getitem__(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatArray___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  floatArray *arg1 = 0 ;
  size_t arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:floatArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_floatArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray___setitem__" "', argument " "1"" of type '" "floatArray *""'"); 
  }
  arg1 = reinterpret_cast< floatArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "floatArray___setitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "floatArray___setitem__" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  floatArray___setitem__(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatArray_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  floatArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_floatArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_cast" "', argument " "1"" of type '" "floatArray *""'"); 
  }
  arg1 = reinterpret_cast< floatArray * >(argp1);
  result = (float *)floatArray_cast(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_floatArray_frompointer(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"t",  NULL 
  };
  floatArray *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:floatArray_frompointer", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "floatArray_frompointer" "', argument " "1"" of type '" "float *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  result = (floatArray *)floatArray_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_floatArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *floatArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_floatArray, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *floatArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_doubleP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  double *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_doubleP", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleP" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (double *)new_doubleP(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_doubleP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:delete_doubleP", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doubleP" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  delete_doubleP(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doubleP_getitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleP_getitem", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleP_getitem" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleP_getitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)doubleP_getitem(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doubleP_setitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:doubleP_setitem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleP_setitem" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleP_setitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleP_setitem" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  doubleP_setitem(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_doubleArray(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  doubleArray *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_doubleArray", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_doubleArray" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (doubleArray *)new_doubleArray(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doubleArray, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_doubleArray(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  doubleArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doubleArray, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_doubleArray" "', argument " "1"" of type '" "doubleArray *""'"); 
  }
  arg1 = reinterpret_cast< doubleArray * >(argp1);
  delete_doubleArray(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doubleArray___getitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  doubleArray *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"index",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:doubleArray___getitem__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___getitem__" "', argument " "1"" of type '" "doubleArray *""'"); 
  }
  arg1 = reinterpret_cast< doubleArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___getitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (double)doubleArray___getitem__(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doubleArray___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  doubleArray *arg1 = 0 ;
  size_t arg2 ;
  double arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:doubleArray___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_doubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray___setitem__" "', argument " "1"" of type '" "doubleArray *""'"); 
  }
  arg1 = reinterpret_cast< doubleArray * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "doubleArray___setitem__" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "doubleArray___setitem__" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  doubleArray___setitem__(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doubleArray_cast(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  doubleArray *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_doubleArray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_cast" "', argument " "1"" of type '" "doubleArray *""'"); 
  }
  arg1 = reinterpret_cast< doubleArray * >(argp1);
  result = (double *)doubleArray_cast(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_doubleArray_frompointer(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"t",  NULL 
  };
  doubleArray *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:doubleArray_frompointer", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "doubleArray_frompointer" "', argument " "1"" of type '" "double *""'"); 
  }
  arg1 = reinterpret_cast< double * >(argp1);
  result = (doubleArray *)doubleArray_frompointer(arg1);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_doubleArray, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *doubleArray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_doubleArray, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *doubleArray_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_ushortP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  unsigned short *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_ushortP", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ushortP" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (unsigned short *)new_ushortP(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ushortP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned short *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:delete_ushortP", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ushortP" "', argument " "1"" of type '" "unsigned short *""'"); 
  }
  arg1 = reinterpret_cast< unsigned short * >(argp1);
  delete_ushortP(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ushortP_getitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned short *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  NULL 
  };
  unsigned short result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ushortP_getitem", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ushortP_getitem" "', argument " "1"" of type '" "unsigned short *""'"); 
  }
  arg1 = reinterpret_cast< unsigned short * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ushortP_getitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (unsigned short)ushortP_getitem(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ushortP_setitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned short *arg1 = 0 ;
  size_t arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ushortP_setitem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ushortP_setitem" "', argument " "1"" of type '" "unsigned short *""'"); 
  }
  arg1 = reinterpret_cast< unsigned short * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ushortP_setitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ushortP_setitem" "', argument " "3"" of type '" "unsigned short""'");
  } 
  arg3 = static_cast< unsigned short >(val3);
  ushortP_setitem(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_shortP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"nelements",  NULL 
  };
  short *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_shortP", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_shortP" "', argument " "1"" of type '" "size_t""'");
  } 
  arg1 = static_cast< size_t >(val1);
  result = (short *)new_shortP(SWIG_STD_MOVE(arg1));
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_shortP(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:delete_shortP", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_shortP" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  delete_shortP(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_shortP_getitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  NULL 
  };
  short result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:shortP_getitem", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shortP_getitem" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shortP_getitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  result = (short)shortP_getitem(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_shortP_setitem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  size_t arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"ary",  (char *)"index",  (char *)"value",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:shortP_setitem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shortP_setitem" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shortP_setitem" "', argument " "2"" of type '" "size_t""'");
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_short(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "shortP_setitem" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  shortP_setitem(arg1,SWIG_STD_MOVE(arg2),arg3);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cdata(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  void *arg1 = 0 ;
  size_t arg2 = 1 ;
  int res1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"ptr",  (char *)"nelements",  NULL 
  };
  SWIGCDATA result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:cdata", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cdata" "', argument " "1"" of type '" "void *""'"); 
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cdata" "', argument " "2"" of type '" "size_t""'");
    } 
    arg2 = static_cast< size_t >(val2);
  }
  result = cdata_void(arg1,SWIG_STD_MOVE(arg2));
  resultobj = SWIG_FromCharPtrAndSize((&result)->data,(&result)->len);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_memmove(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  void *arg1 = 0 ;
  void *arg2 = 0 ;
  size_t arg3 ;
  int res1 ;
  int res2 ;
  void *buf2 = 0 ;
  size_t len2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"data",  (char *)"indata",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:memmove", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "memmove" "', argument " "1"" of type '" "void *""'"); 
  }
  res2 = SWIG_AsCharPtrAndSize(obj1, (char **)&buf2, &len2, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "memmove" "', argument " "2"" of type '" "void const *""'");
  }
  arg2 = reinterpret_cast< void * >(buf2);
  arg3 = static_cast< size_t >(len2);
  memmove(arg1,(void const *)arg2,SWIG_STD_MOVE(arg3));
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) {
    delete[] (char*)(buf2);
  }
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) {
    delete[] (char*)(buf2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SwigPyIterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SwigPyIterator" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_value(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_value" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)((swig::SwigPyIterator const *)arg1)->value();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_incr(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  size_t arg2 = 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SwigPyIterator_incr", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_incr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_incr" "', argument " "2"" of type '" "size_t""'");
    } 
    arg2 = static_cast< size_t >(val2);
  }
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->incr(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_decr(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  size_t arg2 = 1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:SwigPyIterator_decr", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_decr" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_size_t(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_decr" "', argument " "2"" of type '" "size_t""'");
    } 
    arg2 = static_cast< size_t >(val2);
  }
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->decr(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_distance(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  ptrdiff_t result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator_distance", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_distance" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator_distance" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      try {
        result = ((swig::SwigPyIterator const *)arg1)->distance((swig::SwigPyIterator const &)*arg2);
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_equal(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  bool result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator_equal", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_equal" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator_equal" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      try {
        result = (bool)((swig::SwigPyIterator const *)arg1)->equal((swig::SwigPyIterator const &)*arg2);
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_copy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_copy" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->copy();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_next(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_next" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->next();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___next__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___next__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->__next__();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_previous(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  PyObject *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_previous" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  {
    try {
      result = (PyObject *)(arg1)->previous();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator_advance(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator_advance", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator_advance" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator_advance" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)(arg1)->advance(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, 0);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___eq__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  bool result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator___eq__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___eq__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator___eq__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = (bool)((swig::SwigPyIterator const *)arg1)->operator ==((swig::SwigPyIterator const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___ne__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  bool result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator___ne__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___ne__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator___ne__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = (bool)((swig::SwigPyIterator const *)arg1)->operator !=((swig::SwigPyIterator const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___iadd__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator___iadd__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___iadd__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___iadd__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *) &(arg1)->operator +=(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (PyErr_Occurred()) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___isub__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator___isub__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___isub__" "', argument " "1"" of type '" "swig::SwigPyIterator *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___isub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *) &(arg1)->operator -=(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (PyErr_Occurred()) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___add__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SwigPyIterator___add__", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___add__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___add__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator +(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::SwigPyIterator *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "ptrdiff_t""'");
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  {
    try {
      result = (swig::SwigPyIterator *)((swig::SwigPyIterator const *)arg1)->operator -(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  swig::SwigPyIterator *arg1 = 0 ;
  swig::SwigPyIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  ptrdiff_t result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_swig__SwigPyIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SwigPyIterator___sub__" "', argument " "1"" of type '" "swig::SwigPyIterator const *""'"); 
  }
  arg1 = reinterpret_cast< swig::SwigPyIterator * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_swig__SwigPyIterator,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SwigPyIterator___sub__" "', argument " "2"" of type '" "swig::SwigPyIterator const &""'"); 
  }
  arg2 = reinterpret_cast< swig::SwigPyIterator * >(argp2);
  {
    try {
      result = ((swig::SwigPyIterator const *)arg1)->operator -((swig::SwigPyIterator const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return resultobj;
fail:
  if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_TypeError)) {
    return NULL;
  }
  PyErr_Clear();
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *_wrap_SwigPyIterator___sub__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SwigPyIterator___sub__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__SwigPyIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SwigPyIterator___sub____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Py_INCREF(Py_NotImplemented);
  return Py_NotImplemented;
}


SWIGINTERN PyObject *SwigPyIterator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_swig__SwigPyIterator, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_new_DoublePair__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::pair< double,double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,double >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePair__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  std::pair< double,double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoublePair" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoublePair" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,double >(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePair__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::pair< double,double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::pair< double,double > *ptr = (std::pair< double,double > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoublePair" "', argument " "1"" of type '" "std::pair< double,double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DoublePair" "', argument " "1"" of type '" "std::pair< double,double > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::pair< double,double > *)new std::pair< double,double >((std::pair< double,double > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoublePair(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DoublePair", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DoublePair__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::pair< double,double >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DoublePair__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_double(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DoublePair__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DoublePair'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::pair< double,double >::pair()\n"
    "    std::pair< double,double >::pair(double,double)\n"
    "    std::pair< double,double >::pair(std::pair< double,double > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoublePair_first_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoublePair_first_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_first_set" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePair_first_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->first = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePair_first_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_first_get" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  result = (double) ((arg1)->first);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePair_second_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "DoublePair_second_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_second_set" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoublePair_second_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->second = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoublePair_second_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoublePair_second_get" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  result = (double) ((arg1)->second);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoublePair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::pair< double,double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__pairT_double_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoublePair" "', argument " "1"" of type '" "std::pair< double,double > *""'"); 
  }
  arg1 = reinterpret_cast< std::pair< double,double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DoublePair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__pairT_double_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DoublePair_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_IntVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_iterator" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_int_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___nonzero__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_int_Sg____nonzero__((std::vector< int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___bool__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_int_Sg____bool__((std::vector< int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___len__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = std_vector_Sl_int_Sg____len__((std::vector< int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___getslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_int_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  std::vector< int,std::allocator< int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntVector___setslice__" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< int,std::allocator< int > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IntVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type)\n"
    "    std::vector< int >::__setslice__(std::vector< int >::difference_type,std::vector< int >::difference_type,std::vector< int,std::allocator< int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delslice__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delslice__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___delslice__" "', argument " "3"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_int_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___delitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_int_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int,std::allocator< int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< int,std::allocator< int > > *)std_vector_Sl_int_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< int,std::allocator< int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< int,std::allocator< int > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___delitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_int_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__delitem__(std::vector< int >::difference_type)\n"
    "    std::vector< int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___getitem__" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___getitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg____getitem____SWIG_1((std::vector< int > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  if (!swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< int >::__getitem__(std::vector< int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::difference_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector___setitem__" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector___setitem__" "', argument " "2"" of type '" "std::vector< int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector___setitem__" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_int_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< int,std::allocator< int > > const &)\n"
    "    std::vector< int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< int >::__setitem__(std::vector< int >::difference_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      try {
        result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_append" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_append" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_int_Sg__append(arg1,(int const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_empty" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (bool)((std::vector< int > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_size" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< int > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_swap" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_int_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntVector_swap" "', argument " "2"" of type '" "std::vector< int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_begin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_end" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rbegin" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_rend" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_clear" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< int > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_get_allocator" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< int > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< int >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  {
    try {
      result = (std::vector< int > *)new std::vector< int >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_pop_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< int >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_int_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< int >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_erase" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_erase" "', argument " "3"" of type '" "std::vector< int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_int_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_IntVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_IntVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::erase(std::vector< int >::iterator)\n"
    "    std::vector< int >::erase(std::vector< int >::iterator,std::vector< int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_IntVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int >::size_type arg1 ;
  std::vector< int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  std::vector< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntVector" "', argument " "1"" of type '" "std::vector< int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< int >::size_type >(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IntVector" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >(SWIG_STD_MOVE(arg1),(std::vector< int >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IntVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IntVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IntVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_IntVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::vector()\n"
    "    std::vector< int >::vector(std::vector< int > const &)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type)\n"
    "    std::vector< int >::vector(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< int >::value_type temp2 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_push_back" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_push_back" "', argument " "2"" of type '" "std::vector< int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< int >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_front" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  if (!swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_back" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = (std::vector< int >::value_type *) &((std::vector< int > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(*result));
  if (!swig::container_owner<swig::traits<std::vector< int >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_assign" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_assign" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_assign" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< int >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::size_type arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_resize" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_resize" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_resize" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< int >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::resize(std::vector< int >::size_type)\n"
    "    std::vector< int >::resize(std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< int >::value_type temp3 ;
  int val3 ;
  int ecode3 = 0 ;
  std::vector< int >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      result = std_vector_Sl_int_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::iterator arg2 ;
  std::vector< int >::size_type arg3 ;
  std::vector< int >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< int >::value_type temp4 ;
  int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_insert" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntVector_insert" "', argument " "2"" of type '" "std::vector< int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntVector_insert" "', argument " "3"" of type '" "std::vector< int >::size_type""'");
  } 
  arg3 = static_cast< std::vector< int >::size_type >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IntVector_insert" "', argument " "4"" of type '" "std::vector< int >::value_type""'");
  } 
  temp4 = static_cast< std::vector< int >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_int_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(int const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_IntVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::value_type const &)\n"
    "    std::vector< int >::insert(std::vector< int >::iterator,std::vector< int >::size_type,std::vector< int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_reserve" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntVector_reserve" "', argument " "2"" of type '" "std::vector< int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntVector_capacity" "', argument " "1"" of type '" "std::vector< int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      result = ((std::vector< int > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntVector" "', argument " "1"" of type '" "std::vector< int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< int > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IntVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IntVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_UIntVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_iterator" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_unsigned_SS_int_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___nonzero__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg____nonzero__((std::vector< unsigned int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___bool__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_unsigned_SS_int_Sg____bool__((std::vector< unsigned int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___len__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg____len__((std::vector< unsigned int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:UIntVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___getslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector___getslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector___getslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< unsigned int,std::allocator< unsigned int > > *)std_vector_Sl_unsigned_SS_int_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___setslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector___setslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector___setslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___setslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector___setslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector___setslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UIntVector___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntVector___setslice__" "', argument " "4"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UIntVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UIntVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__setslice__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::difference_type)\n"
    "    std::vector< unsigned int >::__setslice__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::difference_type,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:UIntVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___delslice__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector___delslice__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector___delslice__" "', argument " "3"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___delitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector___delitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___getitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< unsigned int,std::allocator< unsigned int > > *)std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UIntVector___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntVector___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___delitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UIntVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UIntVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__delitem__(std::vector< unsigned int >::difference_type)\n"
    "    std::vector< unsigned int >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___getitem__" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector___getitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< unsigned int >::value_type *) &std_vector_Sl_unsigned_SS_int_Sg____getitem____SWIG_1((std::vector< unsigned int > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  if (!swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UIntVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UIntVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< unsigned int >::__getitem__(std::vector< unsigned int >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::difference_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector___setitem__" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector___setitem__" "', argument " "2"" of type '" "std::vector< unsigned int >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::difference_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector___setitem__" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_unsigned_SS_int_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(unsigned int const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UIntVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UIntVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UIntVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< unsigned int,std::allocator< unsigned int > > const &)\n"
    "    std::vector< unsigned int >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< unsigned int >::__setitem__(std::vector< unsigned int >::difference_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_pop" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      try {
        result = (std::vector< unsigned int >::value_type)std_vector_Sl_unsigned_SS_int_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_append" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector_append" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_unsigned_SS_int_Sg__append(arg1,(unsigned int const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< unsigned int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_empty" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (bool)((std::vector< unsigned int > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_size" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_swap" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_unsigned_int_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UIntVector_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntVector_swap" "', argument " "2"" of type '" "std::vector< unsigned int > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< unsigned int > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_begin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_end" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_rbegin" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_rend" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_clear" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< unsigned int > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_get_allocator" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< unsigned int >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< unsigned int >::size_type >(val1);
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_pop_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_resize" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector_resize" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< unsigned int >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_erase" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< unsigned int >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_erase" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_erase" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_erase" "', argument " "3"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_erase" "', argument " "3"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_UIntVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_UIntVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::erase(std::vector< unsigned int >::iterator)\n"
    "    std::vector< unsigned int >::erase(std::vector< unsigned int >::iterator,std::vector< unsigned int >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_UIntVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int >::size_type arg1 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg1 = static_cast< std::vector< unsigned int >::size_type >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_UIntVector" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< unsigned int > *)new std::vector< unsigned int >(SWIG_STD_MOVE(arg1),(std::vector< unsigned int >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UIntVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UIntVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UIntVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UIntVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UIntVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UIntVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::vector()\n"
    "    std::vector< unsigned int >::vector(std::vector< unsigned int > const &)\n"
    "    std::vector< unsigned int >::vector(std::vector< unsigned int >::size_type)\n"
    "    std::vector< unsigned int >::vector(std::vector< unsigned int >::size_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< unsigned int >::value_type temp2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_push_back" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector_push_back" "', argument " "2"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp2 = static_cast< std::vector< unsigned int >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< unsigned int >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_front" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (std::vector< unsigned int >::value_type *) &((std::vector< unsigned int > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  if (!swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_back" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = (std::vector< unsigned int >::value_type *) &((std::vector< unsigned int > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(*result));
  if (!swig::container_owner<swig::traits<std::vector< unsigned int >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:UIntVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_assign" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector_assign" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector_assign" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< unsigned int >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_resize" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector_resize" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector_resize" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< unsigned int >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UIntVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UIntVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::resize(std::vector< unsigned int >::size_type)\n"
    "    std::vector< unsigned int >::resize(std::vector< unsigned int >::size_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< unsigned int >::value_type temp3 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::vector< unsigned int >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_insert" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector_insert" "', argument " "3"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp3 = static_cast< std::vector< unsigned int >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      result = std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(unsigned int const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< unsigned int >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::iterator arg2 ;
  std::vector< unsigned int >::size_type arg3 ;
  std::vector< unsigned int >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< unsigned int >::value_type temp4 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_insert" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntVector_insert" "', argument " "2"" of type '" "std::vector< unsigned int >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntVector_insert" "', argument " "3"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg3 = static_cast< std::vector< unsigned int >::size_type >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "UIntVector_insert" "', argument " "4"" of type '" "std::vector< unsigned int >::value_type""'");
  } 
  temp4 = static_cast< std::vector< unsigned int >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_unsigned_SS_int_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(unsigned int const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UIntVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< unsigned int >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UIntVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< unsigned int >::insert(std::vector< unsigned int >::iterator,std::vector< unsigned int >::value_type const &)\n"
    "    std::vector< unsigned int >::insert(std::vector< unsigned int >::iterator,std::vector< unsigned int >::size_type,std::vector< unsigned int >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  std::vector< unsigned int >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_reserve" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntVector_reserve" "', argument " "2"" of type '" "std::vector< unsigned int >::size_type""'");
  } 
  arg2 = static_cast< std::vector< unsigned int >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< unsigned int >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntVector_capacity" "', argument " "1"" of type '" "std::vector< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      result = ((std::vector< unsigned int > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UIntVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UIntVector" "', argument " "1"" of type '" "std::vector< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< unsigned int > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UIntVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_unsigned_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UIntVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_UIntUIntVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_iterator" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____nonzero__((std::vector< std::vector< unsigned int > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___bool__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____bool__((std::vector< std::vector< unsigned int > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___len__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____len__((std::vector< std::vector< unsigned int > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::difference_type arg2 ;
  std::vector< std::vector< unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:UIntUIntVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntUIntVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *)std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::difference_type arg2 ;
  std::vector< std::vector< unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntUIntVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::difference_type arg2 ;
  std::vector< std::vector< unsigned int > >::difference_type arg3 ;
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntUIntVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val3);
  {
    std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *ptr = (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UIntUIntVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntUIntVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UIntUIntVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UIntUIntVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntUIntVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::__setslice__(std::vector< std::vector< unsigned int > >::difference_type,std::vector< std::vector< unsigned int > >::difference_type)\n"
    "    std::vector< std::vector< unsigned int > >::__setslice__(std::vector< std::vector< unsigned int > >::difference_type,std::vector< std::vector< unsigned int > >::difference_type,std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::difference_type arg2 ;
  std::vector< std::vector< unsigned int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:UIntUIntVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntUIntVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *)std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *ptr = (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UIntUIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntUIntVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UIntUIntVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UIntUIntVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntUIntVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::__delitem__(std::vector< std::vector< unsigned int > >::difference_type)\n"
    "    std::vector< std::vector< unsigned int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< unsigned int > >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< unsigned int > >::value_type *) &std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____getitem____SWIG_1((std::vector< std::vector< unsigned int > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntUIntVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UIntUIntVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UIntUIntVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntUIntVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< unsigned int > >::__getitem__(std::vector< std::vector< unsigned int > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::difference_type arg2 ;
  std::vector< std::vector< unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::difference_type >(val2);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UIntUIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntUIntVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_UIntUIntVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UIntUIntVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UIntUIntVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntUIntVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > const &)\n"
    "    std::vector< std::vector< unsigned int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< unsigned int > >::__setitem__(std::vector< std::vector< unsigned int > >::difference_type,std::vector< std::vector< unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntUIntVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_append" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UIntUIntVector_append" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector_append" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__append(arg1,(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntUIntVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::vector< unsigned int > > *)new std::vector< std::vector< unsigned int > >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntUIntVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::vector< unsigned int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *ptr = (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_UIntUIntVector" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UIntUIntVector" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< unsigned int > > *)new std::vector< std::vector< unsigned int > >((std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::vector< unsigned int > > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_size" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< unsigned int > > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntUIntVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UIntUIntVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_end" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< unsigned int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< unsigned int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< unsigned int > > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< unsigned int > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntUIntVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::vector< unsigned int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UIntUIntVector" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< unsigned int > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::vector< unsigned int > > *)new std::vector< std::vector< unsigned int > >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::vector< unsigned int > >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::iterator arg2 ;
  std::vector< std::vector< unsigned int > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::vector< unsigned int > >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntUIntVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_UIntUIntVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_UIntUIntVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntUIntVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::erase(std::vector< std::vector< unsigned int > >::iterator)\n"
    "    std::vector< std::vector< unsigned int > >::erase(std::vector< std::vector< unsigned int > >::iterator,std::vector< std::vector< unsigned int > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_UIntUIntVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > >::size_type arg1 ;
  std::vector< std::vector< unsigned int > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< unsigned int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UIntUIntVector" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< unsigned int > >::size_type >(val1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_UIntUIntVector" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_UIntUIntVector" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< unsigned int > > *)new std::vector< std::vector< unsigned int > >(SWIG_STD_MOVE(arg1),(std::vector< std::vector< unsigned int > >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_UIntUIntVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_UIntUIntVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_UIntUIntVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_UIntUIntVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UIntUIntVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_UIntUIntVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_UIntUIntVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::vector()\n"
    "    std::vector< std::vector< unsigned int > >::vector(std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > const &)\n"
    "    std::vector< std::vector< unsigned int > >::vector(std::vector< std::vector< unsigned int > >::size_type)\n"
    "    std::vector< std::vector< unsigned int > >::vector(std::vector< std::vector< unsigned int > >::size_type,std::vector< std::vector< unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntUIntVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "UIntUIntVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< unsigned int > >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_front" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< unsigned int > >::value_type *) &((std::vector< std::vector< unsigned int > > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_back" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< unsigned int > >::value_type *) &((std::vector< std::vector< unsigned int > > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< unsigned int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::size_type arg2 ;
  std::vector< std::vector< unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:UIntUIntVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::size_type >(val2);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UIntUIntVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< std::vector< unsigned int > >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::size_type arg2 ;
  std::vector< std::vector< unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::size_type >(val2);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UIntUIntVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< std::vector< unsigned int > >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntUIntVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UIntUIntVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UIntUIntVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntUIntVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::resize(std::vector< std::vector< unsigned int > >::size_type)\n"
    "    std::vector< std::vector< unsigned int > >::resize(std::vector< std::vector< unsigned int > >::size_type,std::vector< std::vector< unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::iterator arg2 ;
  std::vector< std::vector< unsigned int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::vector< unsigned int > >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
    }
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "UIntUIntVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< unsigned int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::iterator arg2 ;
  std::vector< std::vector< unsigned int > >::size_type arg3 ;
  std::vector< std::vector< unsigned int > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "UIntUIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "UIntUIntVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< unsigned int > >::size_type >(val3);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "UIntUIntVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "UIntUIntVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< unsigned int > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_unsigned_SS_int_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< unsigned int,std::allocator< unsigned int > > const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "UIntUIntVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UIntUIntVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< unsigned int > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UIntUIntVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'UIntUIntVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< unsigned int > >::insert(std::vector< std::vector< unsigned int > >::iterator,std::vector< std::vector< unsigned int > >::value_type const &)\n"
    "    std::vector< std::vector< unsigned int > >::insert(std::vector< std::vector< unsigned int > >::iterator,std::vector< std::vector< unsigned int > >::size_type,std::vector< std::vector< unsigned int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  std::vector< std::vector< unsigned int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:UIntUIntVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UIntUIntVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< unsigned int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< unsigned int > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_UIntUIntVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< unsigned int > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UIntUIntVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< unsigned int > > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_UIntUIntVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< unsigned int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_UIntUIntVector" "', argument " "1"" of type '" "std::vector< std::vector< unsigned int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< unsigned int > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *UIntUIntVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_unsigned_int_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *UIntUIntVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DoubleVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_iterator" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_double_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___nonzero__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_double_Sg____nonzero__((std::vector< double > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___bool__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_double_Sg____bool__((std::vector< double > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___len__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = std_vector_Sl_double_Sg____len__((std::vector< double > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DoubleVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___getslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_double_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  std::vector< double,std::allocator< double > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< double,std::allocator< double > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DoubleVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type)\n"
    "    std::vector< double >::__setslice__(std::vector< double >::difference_type,std::vector< double >::difference_type,std::vector< double,std::allocator< double > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DoubleVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delslice__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delslice__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___delslice__" "', argument " "3"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< double >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_double_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___delitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_double_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double,std::allocator< double > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< double,std::allocator< double > > *)std_vector_Sl_double_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< double,std::allocator< double > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_double_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoubleVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__delitem__(std::vector< double >::difference_type)\n"
    "    std::vector< double >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___getitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< double >::value_type *) &std_vector_Sl_double_Sg____getitem____SWIG_1((std::vector< double > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  if (!swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoubleVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< double >::__getitem__(std::vector< double >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::difference_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector___setitem__" "', argument " "2"" of type '" "std::vector< double >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< double >::difference_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      try {
        std_vector_Sl_double_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoubleVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoubleVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< double,std::allocator< double > > const &)\n"
    "    std::vector< double >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< double >::__setitem__(std::vector< double >::difference_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      try {
        result = (std::vector< double >::value_type)std_vector_Sl_double_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_append" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_append" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      std_vector_Sl_double_Sg__append(arg1,(double const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< double > *)new std::vector< double >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_empty" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (bool)((std::vector< double > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_size" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_swap" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_double_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleVector_swap" "', argument " "2"" of type '" "std::vector< double > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< double > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_begin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_end" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rbegin" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_rend" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_clear" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< double > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_get_allocator" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< double >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_double_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  {
    try {
      result = (std::vector< double > *)new std::vector< double >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_pop_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_double_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< double >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_erase" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_erase" "', argument " "3"" of type '" "std::vector< double >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_double_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DoubleVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DoubleVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::erase(std::vector< double >::iterator)\n"
    "    std::vector< double >::erase(std::vector< double >::iterator,std::vector< double >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double >::size_type arg1 ;
  std::vector< double >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  std::vector< double > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleVector" "', argument " "1"" of type '" "std::vector< double >::size_type""'");
  } 
  arg1 = static_cast< std::vector< double >::size_type >(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_DoubleVector" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      result = (std::vector< double > *)new std::vector< double >(SWIG_STD_MOVE(arg1),(std::vector< double >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DoubleVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DoubleVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DoubleVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DoubleVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_DoubleVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DoubleVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::vector()\n"
    "    std::vector< double >::vector(std::vector< double > const &)\n"
    "    std::vector< double >::vector(std::vector< double >::size_type)\n"
    "    std::vector< double >::vector(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< double >::value_type temp2 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_push_back" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_push_back" "', argument " "2"" of type '" "std::vector< double >::value_type""'");
  } 
  temp2 = static_cast< std::vector< double >::value_type >(val2);
  arg2 = &temp2;
  {
    try {
      (arg1)->push_back((std::vector< double >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_front" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  if (!swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_back" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = (std::vector< double >::value_type *) &((std::vector< double > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(*result));
  if (!swig::container_owner<swig::traits<std::vector< double >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DoubleVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_assign" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_assign" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_assign" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< double >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::size_type arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_resize" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_resize" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_resize" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< double >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::resize(std::vector< double >::size_type)\n"
    "    std::vector< double >::resize(std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< double >::value_type temp3 ;
  double val3 ;
  int ecode3 = 0 ;
  std::vector< double >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::value_type""'");
  } 
  temp3 = static_cast< std::vector< double >::value_type >(val3);
  arg3 = &temp3;
  {
    try {
      result = std_vector_Sl_double_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(double const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< double >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::iterator arg2 ;
  std::vector< double >::size_type arg3 ;
  std::vector< double >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  std::vector< double >::value_type temp4 ;
  double val4 ;
  int ecode4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_insert" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< double >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleVector_insert" "', argument " "2"" of type '" "std::vector< double >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleVector_insert" "', argument " "3"" of type '" "std::vector< double >::size_type""'");
  } 
  arg3 = static_cast< std::vector< double >::size_type >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DoubleVector_insert" "', argument " "4"" of type '" "std::vector< double >::value_type""'");
  } 
  temp4 = static_cast< std::vector< double >::value_type >(val4);
  arg4 = &temp4;
  {
    try {
      std_vector_Sl_double_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(double const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< double >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_DoubleVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::value_type const &)\n"
    "    std::vector< double >::insert(std::vector< double >::iterator,std::vector< double >::size_type,std::vector< double >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  std::vector< double >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_reserve" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleVector_reserve" "', argument " "2"" of type '" "std::vector< double >::size_type""'");
  } 
  arg2 = static_cast< std::vector< double >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleVector_capacity" "', argument " "1"" of type '" "std::vector< double > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      result = ((std::vector< double > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< double > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_double_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleVector" "', argument " "1"" of type '" "std::vector< double > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< double > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DoubleVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_double_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DoubleVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_StringVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_iterator" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_string_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg____nonzero__((std::vector< std::string > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___bool__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_string_Sg____bool__((std::vector< std::string > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___len__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_string_Sg____len__((std::vector< std::string > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:StringVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___getslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___getslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___getslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  std::vector< std::string,std::allocator< std::string > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___setslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___setslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringVector___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector___setslice__" "', argument " "4"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::string,std::allocator< std::string > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::string,std::allocator< std::string > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__setslice__(std::vector< std::string >::difference_type,std::vector< std::string >::difference_type,std::vector< std::string,std::allocator< std::string > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:StringVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___delslice__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___delslice__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector___delslice__" "', argument " "3"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___delitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___getitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::string,std::allocator< std::string > > *)std_vector_Sl_std_string_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::string,std::allocator< std::string > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___delitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__delitem__(std::vector< std::string >::difference_type)\n"
    "    std::vector< std::string >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___getitem__" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___getitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg____getitem____SWIG_1((std::vector< std::string > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::string >::__getitem__(std::vector< std::string >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::difference_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector___setitem__" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector___setitem__" "', argument " "2"" of type '" "std::vector< std::string >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::difference_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector___setitem__" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_string_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_StringVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::string,std::allocator< std::string > > const &)\n"
    "    std::vector< std::string >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::string >::__setitem__(std::vector< std::string >::difference_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_pop" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:StringVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_append" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_append" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_string_Sg__append(arg1,(std::string const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_empty" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::string > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_size" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:StringVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_swap" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__string_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_swap" "', argument " "2"" of type '" "std::vector< std::string > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::string > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_begin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_end" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_rbegin" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_rend" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_clear" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::string > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::string >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__string_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_pop_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_erase" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_erase" "', argument " "3"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_StringVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_StringVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator)\n"
    "    std::vector< std::string >::erase(std::vector< std::string >::iterator,std::vector< std::string >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_StringVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string >::size_type arg1 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::string > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_StringVector" "', argument " "1"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::string >::size_type >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_StringVector" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_StringVector" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >(SWIG_STD_MOVE(arg1),(std::vector< std::string >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_StringVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_StringVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_StringVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_StringVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StringVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_StringVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_StringVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::vector()\n"
    "    std::vector< std::string >::vector(std::vector< std::string > const &)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::vector(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:StringVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_push_back" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StringVector_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_push_back" "', argument " "2"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::string >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_front" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_back" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = (std::vector< std::string >::value_type *) &((std::vector< std::string > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::string >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:StringVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_assign" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_assign" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_assign" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< std::string >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::size_type arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_resize" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_resize" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_resize" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< std::string >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type)\n"
    "    std::vector< std::string >::resize(std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::string >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_string_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::string >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::iterator arg2 ;
  std::vector< std::string >::size_type arg3 ;
  std::vector< std::string >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_insert" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::string >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "StringVector_insert" "', argument " "2"" of type '" "std::vector< std::string >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "StringVector_insert" "', argument " "3"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::string >::size_type >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "StringVector_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "StringVector_insert" "', argument " "4"" of type '" "std::vector< std::string >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_string_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::string const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "StringVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_StringVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::string >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'StringVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::value_type const &)\n"
    "    std::vector< std::string >::insert(std::vector< std::string >::iterator,std::vector< std::string >::size_type,std::vector< std::string >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_StringVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:StringVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_reserve" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "StringVector_reserve" "', argument " "2"" of type '" "std::vector< std::string >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::string >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_StringVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::string >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StringVector_capacity" "', argument " "1"" of type '" "std::vector< std::string > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_StringVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::string > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_StringVector" "', argument " "1"" of type '" "std::vector< std::string > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::string > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *StringVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__string_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *StringVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ConstCharVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_iterator" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_char_SS_const_Sm__Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___nonzero__" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_char_SS_const_Sm__Sg____nonzero__((std::vector< char const * > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___bool__" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_char_SS_const_Sm__Sg____bool__((std::vector< char const * > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___len__" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = std_vector_Sl_char_SS_const_Sm__Sg____len__((std::vector< char const * > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::difference_type arg2 ;
  std::vector< char const * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< char const *,std::allocator< char const * > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstCharVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___getslice__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector___getslice__" "', argument " "2"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConstCharVector___getslice__" "', argument " "3"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< char const * >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< char const *,std::allocator< char const * > > *)std_vector_Sl_char_SS_const_Sm__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::difference_type arg2 ;
  std::vector< char const * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___setslice__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector___setslice__" "', argument " "2"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConstCharVector___setslice__" "', argument " "3"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< char const * >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::difference_type arg2 ;
  std::vector< char const * >::difference_type arg3 ;
  std::vector< char const *,std::allocator< char const * > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___setslice__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector___setslice__" "', argument " "2"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConstCharVector___setslice__" "', argument " "3"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< char const * >::difference_type >(val3);
  {
    std::vector< char const*,std::allocator< char const * > > *ptr = (std::vector< char const*,std::allocator< char const * > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConstCharVector___setslice__" "', argument " "4"" of type '" "std::vector< char const *,std::allocator< char const * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ConstCharVector___setslice__" "', argument " "4"" of type '" "std::vector< char const *,std::allocator< char const * > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< char const *,std::allocator< char const * > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConstCharVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ConstCharVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< char const*,std::allocator< char const * > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConstCharVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConstCharVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::__setslice__(std::vector< char const * >::difference_type,std::vector< char const * >::difference_type)\n"
    "    std::vector< char const * >::__setslice__(std::vector< char const * >::difference_type,std::vector< char const * >::difference_type,std::vector< char const *,std::allocator< char const * > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::difference_type arg2 ;
  std::vector< char const * >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstCharVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___delslice__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector___delslice__" "', argument " "2"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConstCharVector___delslice__" "', argument " "3"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< char const * >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___delitem__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector___delitem__" "', argument " "2"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< char const *,std::allocator< char const * > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___getitem__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< char const *,std::allocator< char const * > > *)std_vector_Sl_char_SS_const_Sm__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< char const *,std::allocator< char const * > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___setitem__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< char const*,std::allocator< char const * > > *ptr = (std::vector< char const*,std::allocator< char const * > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstCharVector___setitem__" "', argument " "3"" of type '" "std::vector< char const *,std::allocator< char const * > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ConstCharVector___setitem__" "', argument " "3"" of type '" "std::vector< char const *,std::allocator< char const * > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< char const *,std::allocator< char const * > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___setitem__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___delitem__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConstCharVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ConstCharVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConstCharVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConstCharVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::__delitem__(std::vector< char const * >::difference_type)\n"
    "    std::vector< char const * >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< char const * >::value_type result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___getitem__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector___getitem__" "', argument " "2"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< char const * >::value_type)std_vector_Sl_char_SS_const_Sm__Sg____getitem____SWIG_1(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConstCharVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ConstCharVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConstCharVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConstCharVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< char const * >::__getitem__(std::vector< char const * >::difference_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::difference_type arg2 ;
  std::vector< char const * >::value_type arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector___setitem__" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector___setitem__" "', argument " "2"" of type '" "std::vector< char const * >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::difference_type >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstCharVector___setitem__" "', argument " "3"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg3 = reinterpret_cast< std::vector< char const * >::value_type >(buf3);
  {
    try {
      try {
        std_vector_Sl_char_SS_const_Sm__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(char const *)arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConstCharVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ConstCharVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< char const*,std::allocator< char const * > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ConstCharVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ConstCharVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConstCharVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< char const *,std::allocator< char const * > > const &)\n"
    "    std::vector< char const * >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< char const * >::__setitem__(std::vector< char const * >::difference_type,std::vector< char const * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_pop" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      try {
        result = (std::vector< char const * >::value_type)std_vector_Sl_char_SS_const_Sm__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::value_type arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ConstCharVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_append" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstCharVector_append" "', argument " "2"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg2 = reinterpret_cast< std::vector< char const * >::value_type >(buf2);
  {
    try {
      std_vector_Sl_char_SS_const_Sm__Sg__append(arg1,(char const *)arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstCharVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< char const * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< char const * > *)new std::vector< char const * >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstCharVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< char const * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< char const*,std::allocator< char const * > > *ptr = (std::vector< char const*,std::allocator< char const * > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ConstCharVector" "', argument " "1"" of type '" "std::vector< char const * > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ConstCharVector" "', argument " "1"" of type '" "std::vector< char const * > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< char const * > *)new std::vector< char const * >((std::vector< char const * > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_empty" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (bool)((std::vector< char const * > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_size" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = ((std::vector< char const * > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ConstCharVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_swap" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_char_const_p_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstCharVector_swap" "', argument " "2"" of type '" "std::vector< char const * > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ConstCharVector_swap" "', argument " "2"" of type '" "std::vector< char const * > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< char const * > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_begin" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char const * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_end" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char const * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_rbegin" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char const * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_rend" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char const * >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_clear" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< char const * > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_get_allocator" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = ((std::vector< char const * > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< char const * >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_char_const_p_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstCharVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< char const * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstCharVector" "', argument " "1"" of type '" "std::vector< char const * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< char const * >::size_type >(val1);
  {
    try {
      result = (std::vector< char const * > *)new std::vector< char const * >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_pop_back" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_resize" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector_resize" "', argument " "2"" of type '" "std::vector< char const * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< char const * >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_erase" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_erase" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< char const * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_erase" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_char_SS_const_Sm__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char const * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::iterator arg2 ;
  std::vector< char const * >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< char const * >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_erase" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_erase" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< char const * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_erase" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_erase" "', argument " "3"" of type '" "std::vector< char const * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< char const * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_erase" "', argument " "3"" of type '" "std::vector< char const * >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_char_SS_const_Sm__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char const * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConstCharVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_ConstCharVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_ConstCharVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConstCharVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::erase(std::vector< char const * >::iterator)\n"
    "    std::vector< char const * >::erase(std::vector< char const * >::iterator,std::vector< char const * >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ConstCharVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * >::size_type arg1 ;
  std::vector< char const * >::value_type arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  std::vector< char const * > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ConstCharVector" "', argument " "1"" of type '" "std::vector< char const * >::size_type""'");
  } 
  arg1 = static_cast< std::vector< char const * >::size_type >(val1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ConstCharVector" "', argument " "2"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg2 = reinterpret_cast< std::vector< char const * >::value_type >(buf2);
  {
    try {
      result = (std::vector< char const * > *)new std::vector< char const * >(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_POINTER_NEW |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ConstCharVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ConstCharVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ConstCharVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ConstCharVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConstCharVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ConstCharVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ConstCharVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::vector()\n"
    "    std::vector< char const * >::vector(std::vector< char const * > const &)\n"
    "    std::vector< char const * >::vector(std::vector< char const * >::size_type)\n"
    "    std::vector< char const * >::vector(std::vector< char const * >::size_type,std::vector< char const * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::value_type arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ConstCharVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_push_back" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ConstCharVector_push_back" "', argument " "2"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg2 = reinterpret_cast< std::vector< char const * >::value_type >(buf2);
  {
    try {
      (arg1)->push_back(arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_front" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (std::vector< char const * >::value_type)((std::vector< char const * > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_back" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = (std::vector< char const * >::value_type)((std::vector< char const * > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::size_type arg2 ;
  std::vector< char const * >::value_type arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ConstCharVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_assign" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector_assign" "', argument " "2"" of type '" "std::vector< char const * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::size_type >(val2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstCharVector_assign" "', argument " "3"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg3 = reinterpret_cast< std::vector< char const * >::value_type >(buf3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::size_type arg2 ;
  std::vector< char const * >::value_type arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_resize" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector_resize" "', argument " "2"" of type '" "std::vector< char const * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::size_type >(val2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstCharVector_resize" "', argument " "3"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg3 = reinterpret_cast< std::vector< char const * >::value_type >(buf3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConstCharVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConstCharVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ConstCharVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConstCharVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::resize(std::vector< char const * >::size_type)\n"
    "    std::vector< char const * >::resize(std::vector< char const * >::size_type,std::vector< char const * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::iterator arg2 ;
  std::vector< char const * >::value_type arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  std::vector< char const * >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_insert" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_insert" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< char const * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_insert" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
    }
  }
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ConstCharVector_insert" "', argument " "3"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg3 = reinterpret_cast< std::vector< char const * >::value_type >(buf3);
  {
    try {
      result = std_vector_Sl_char_SS_const_Sm__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(char const *)arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< char const * >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::iterator arg2 ;
  std::vector< char const * >::size_type arg3 ;
  std::vector< char const * >::value_type arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_insert" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_insert" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< char const * >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ConstCharVector_insert" "', argument " "2"" of type '" "std::vector< char const * >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ConstCharVector_insert" "', argument " "3"" of type '" "std::vector< char const * >::size_type""'");
  } 
  arg3 = static_cast< std::vector< char const * >::size_type >(val3);
  res4 = SWIG_AsCharPtrAndSize(swig_obj[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ConstCharVector_insert" "', argument " "4"" of type '" "std::vector< char const * >::value_type""'");
  }
  arg4 = reinterpret_cast< std::vector< char const * >::value_type >(buf4);
  {
    try {
      std_vector_Sl_char_SS_const_Sm__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(char const *)arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return resultobj;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ConstCharVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ConstCharVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< char const*,std::allocator< char const * > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< char const * >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConstCharVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ConstCharVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< char const * >::insert(std::vector< char const * >::iterator,std::vector< char const * >::value_type)\n"
    "    std::vector< char const * >::insert(std::vector< char const * >::iterator,std::vector< char const * >::size_type,std::vector< char const * >::value_type)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  std::vector< char const * >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ConstCharVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_reserve" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ConstCharVector_reserve" "', argument " "2"" of type '" "std::vector< char const * >::size_type""'");
  } 
  arg2 = static_cast< std::vector< char const * >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ConstCharVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< char const * >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ConstCharVector_capacity" "', argument " "1"" of type '" "std::vector< char const * > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      result = ((std::vector< char const * > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ConstCharVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< char const * > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ConstCharVector" "', argument " "1"" of type '" "std::vector< char const * > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< char const * > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ConstCharVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_char_const_p_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ConstCharVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SOLUTIONVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_iterator" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_SOLUTION_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___nonzero__" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_SOLUTION_Sg____nonzero__((std::vector< SOLUTION > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___bool__" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_SOLUTION_Sg____bool__((std::vector< SOLUTION > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___len__" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = std_vector_Sl_SOLUTION_Sg____len__((std::vector< SOLUTION > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::difference_type arg2 ;
  std::vector< SOLUTION >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< SOLUTION,std::allocator< SOLUTION > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SOLUTIONVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___getslice__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector___getslice__" "', argument " "2"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SOLUTIONVector___getslice__" "', argument " "3"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< SOLUTION >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< SOLUTION,std::allocator< SOLUTION > > *)std_vector_Sl_SOLUTION_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::difference_type arg2 ;
  std::vector< SOLUTION >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___setslice__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector___setslice__" "', argument " "2"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SOLUTIONVector___setslice__" "', argument " "3"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< SOLUTION >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::difference_type arg2 ;
  std::vector< SOLUTION >::difference_type arg3 ;
  std::vector< SOLUTION,std::allocator< SOLUTION > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___setslice__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector___setslice__" "', argument " "2"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SOLUTIONVector___setslice__" "', argument " "3"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< SOLUTION >::difference_type >(val3);
  {
    std::vector< SOLUTION,std::allocator< SOLUTION > > *ptr = (std::vector< SOLUTION,std::allocator< SOLUTION > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SOLUTIONVector___setslice__" "', argument " "4"" of type '" "std::vector< SOLUTION,std::allocator< SOLUTION > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector___setslice__" "', argument " "4"" of type '" "std::vector< SOLUTION,std::allocator< SOLUTION > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< SOLUTION,std::allocator< SOLUTION > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SOLUTIONVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SOLUTIONVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SOLUTIONVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SOLUTIONVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::__setslice__(std::vector< SOLUTION >::difference_type,std::vector< SOLUTION >::difference_type)\n"
    "    std::vector< SOLUTION >::__setslice__(std::vector< SOLUTION >::difference_type,std::vector< SOLUTION >::difference_type,std::vector< SOLUTION,std::allocator< SOLUTION > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::difference_type arg2 ;
  std::vector< SOLUTION >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SOLUTIONVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___delslice__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector___delslice__" "', argument " "2"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SOLUTIONVector___delslice__" "', argument " "3"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< SOLUTION >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___delitem__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector___delitem__" "', argument " "2"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< SOLUTION,std::allocator< SOLUTION > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___getitem__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< SOLUTION,std::allocator< SOLUTION > > *)std_vector_Sl_SOLUTION_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< SOLUTION,std::allocator< SOLUTION > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___setitem__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< SOLUTION,std::allocator< SOLUTION > > *ptr = (std::vector< SOLUTION,std::allocator< SOLUTION > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SOLUTIONVector___setitem__" "', argument " "3"" of type '" "std::vector< SOLUTION,std::allocator< SOLUTION > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector___setitem__" "', argument " "3"" of type '" "std::vector< SOLUTION,std::allocator< SOLUTION > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< SOLUTION,std::allocator< SOLUTION > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___setitem__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___delitem__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SOLUTIONVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SOLUTIONVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SOLUTIONVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SOLUTIONVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::__delitem__(std::vector< SOLUTION >::difference_type)\n"
    "    std::vector< SOLUTION >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< SOLUTION >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___getitem__" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector___getitem__" "', argument " "2"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< SOLUTION >::value_type *) &std_vector_Sl_SOLUTION_Sg____getitem____SWIG_1((std::vector< SOLUTION > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< SOLUTION >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SOLUTIONVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SOLUTIONVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SOLUTIONVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SOLUTIONVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< SOLUTION >::__getitem__(std::vector< SOLUTION >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::difference_type arg2 ;
  std::vector< SOLUTION >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector___setitem__" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector___setitem__" "', argument " "2"" of type '" "std::vector< SOLUTION >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SOLUTIONVector___setitem__" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector___setitem__" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_SOLUTION_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(SOLUTION const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SOLUTIONVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SOLUTIONVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SOLUTIONVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SOLUTION, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SOLUTIONVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SOLUTIONVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< SOLUTION,std::allocator< SOLUTION > > const &)\n"
    "    std::vector< SOLUTION >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< SOLUTION >::__setitem__(std::vector< SOLUTION >::difference_type,std::vector< SOLUTION >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_pop" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_SOLUTION_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< SOLUTION >::value_type(result)), SWIGTYPE_p_SOLUTION, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SOLUTIONVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_append" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SOLUTIONVector_append" "', argument " "2"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector_append" "', argument " "2"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_SOLUTION_Sg__append(arg1,(SOLUTION const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SOLUTIONVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< SOLUTION > *)new std::vector< SOLUTION >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SOLUTIONVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< SOLUTION > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< SOLUTION,std::allocator< SOLUTION > > *ptr = (std::vector< SOLUTION,std::allocator< SOLUTION > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SOLUTIONVector" "', argument " "1"" of type '" "std::vector< SOLUTION > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SOLUTIONVector" "', argument " "1"" of type '" "std::vector< SOLUTION > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< SOLUTION > *)new std::vector< SOLUTION >((std::vector< SOLUTION > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_empty" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (bool)((std::vector< SOLUTION > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_size" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = ((std::vector< SOLUTION > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SOLUTIONVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_swap" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_SOLUTION_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SOLUTIONVector_swap" "', argument " "2"" of type '" "std::vector< SOLUTION > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector_swap" "', argument " "2"" of type '" "std::vector< SOLUTION > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< SOLUTION > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_begin" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< SOLUTION >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_end" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< SOLUTION >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_rbegin" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< SOLUTION >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_rend" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< SOLUTION >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_clear" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< SOLUTION > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_get_allocator" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = ((std::vector< SOLUTION > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< SOLUTION >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_SOLUTION_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SOLUTIONVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< SOLUTION > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SOLUTIONVector" "', argument " "1"" of type '" "std::vector< SOLUTION >::size_type""'");
  } 
  arg1 = static_cast< std::vector< SOLUTION >::size_type >(val1);
  {
    try {
      result = (std::vector< SOLUTION > *)new std::vector< SOLUTION >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_pop_back" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_resize" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector_resize" "', argument " "2"" of type '" "std::vector< SOLUTION >::size_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< SOLUTION >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_erase" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_erase" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_erase" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_SOLUTION_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< SOLUTION >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::iterator arg2 ;
  std::vector< SOLUTION >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< SOLUTION >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_erase" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_erase" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_erase" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_erase" "', argument " "3"" of type '" "std::vector< SOLUTION >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_erase" "', argument " "3"" of type '" "std::vector< SOLUTION >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_SOLUTION_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< SOLUTION >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SOLUTIONVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_SOLUTIONVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_SOLUTIONVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SOLUTIONVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::erase(std::vector< SOLUTION >::iterator)\n"
    "    std::vector< SOLUTION >::erase(std::vector< SOLUTION >::iterator,std::vector< SOLUTION >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SOLUTIONVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION >::size_type arg1 ;
  std::vector< SOLUTION >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< SOLUTION > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SOLUTIONVector" "', argument " "1"" of type '" "std::vector< SOLUTION >::size_type""'");
  } 
  arg1 = static_cast< std::vector< SOLUTION >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SOLUTIONVector" "', argument " "2"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SOLUTIONVector" "', argument " "2"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp2);
  {
    try {
      result = (std::vector< SOLUTION > *)new std::vector< SOLUTION >(SWIG_STD_MOVE(arg1),(std::vector< SOLUTION >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SOLUTIONVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SOLUTIONVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SOLUTIONVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SOLUTIONVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SOLUTIONVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_SOLUTION, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SOLUTIONVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SOLUTIONVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::vector()\n"
    "    std::vector< SOLUTION >::vector(std::vector< SOLUTION > const &)\n"
    "    std::vector< SOLUTION >::vector(std::vector< SOLUTION >::size_type)\n"
    "    std::vector< SOLUTION >::vector(std::vector< SOLUTION >::size_type,std::vector< SOLUTION >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SOLUTIONVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_push_back" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SOLUTIONVector_push_back" "', argument " "2"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector_push_back" "', argument " "2"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< SOLUTION >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_front" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (std::vector< SOLUTION >::value_type *) &((std::vector< SOLUTION > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< SOLUTION >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_back" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = (std::vector< SOLUTION >::value_type *) &((std::vector< SOLUTION > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< SOLUTION >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::size_type arg2 ;
  std::vector< SOLUTION >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SOLUTIONVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_assign" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector_assign" "', argument " "2"" of type '" "std::vector< SOLUTION >::size_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SOLUTIONVector_assign" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector_assign" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< SOLUTION >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::size_type arg2 ;
  std::vector< SOLUTION >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_resize" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector_resize" "', argument " "2"" of type '" "std::vector< SOLUTION >::size_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SOLUTIONVector_resize" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector_resize" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< SOLUTION >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SOLUTIONVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SOLUTIONVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SOLUTION, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SOLUTIONVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SOLUTIONVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::resize(std::vector< SOLUTION >::size_type)\n"
    "    std::vector< SOLUTION >::resize(std::vector< SOLUTION >::size_type,std::vector< SOLUTION >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::iterator arg2 ;
  std::vector< SOLUTION >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< SOLUTION >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_insert" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_insert" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_insert" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SOLUTIONVector_insert" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector_insert" "', argument " "3"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_SOLUTION_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(SOLUTION const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< SOLUTION >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::iterator arg2 ;
  std::vector< SOLUTION >::size_type arg3 ;
  std::vector< SOLUTION >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_insert" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_insert" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SOLUTIONVector_insert" "', argument " "2"" of type '" "std::vector< SOLUTION >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SOLUTIONVector_insert" "', argument " "3"" of type '" "std::vector< SOLUTION >::size_type""'");
  } 
  arg3 = static_cast< std::vector< SOLUTION >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_SOLUTION,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SOLUTIONVector_insert" "', argument " "4"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SOLUTIONVector_insert" "', argument " "4"" of type '" "std::vector< SOLUTION >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< SOLUTION >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_SOLUTION_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(SOLUTION const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SOLUTIONVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_SOLUTION, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SOLUTIONVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< SOLUTION,std::allocator< SOLUTION > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< SOLUTION >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_SOLUTION, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SOLUTIONVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SOLUTIONVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< SOLUTION >::insert(std::vector< SOLUTION >::iterator,std::vector< SOLUTION >::value_type const &)\n"
    "    std::vector< SOLUTION >::insert(std::vector< SOLUTION >::iterator,std::vector< SOLUTION >::size_type,std::vector< SOLUTION >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  std::vector< SOLUTION >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SOLUTIONVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_reserve" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTIONVector_reserve" "', argument " "2"" of type '" "std::vector< SOLUTION >::size_type""'");
  } 
  arg2 = static_cast< std::vector< SOLUTION >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTIONVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< SOLUTION >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTIONVector_capacity" "', argument " "1"" of type '" "std::vector< SOLUTION > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      result = ((std::vector< SOLUTION > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SOLUTIONVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< SOLUTION > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SOLUTIONVector" "', argument " "1"" of type '" "std::vector< SOLUTION > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< SOLUTION > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SOLUTIONVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_SOLUTION_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SOLUTIONVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_CoordinateVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_iterator" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_COORDINATE_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___nonzero__" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_COORDINATE_Sg____nonzero__((std::vector< COORDINATE > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___bool__" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_COORDINATE_Sg____bool__((std::vector< COORDINATE > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___len__" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = std_vector_Sl_COORDINATE_Sg____len__((std::vector< COORDINATE > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::difference_type arg2 ;
  std::vector< COORDINATE >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< COORDINATE,std::allocator< COORDINATE > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CoordinateVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___getslice__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector___getslice__" "', argument " "2"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoordinateVector___getslice__" "', argument " "3"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< COORDINATE >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< COORDINATE,std::allocator< COORDINATE > > *)std_vector_Sl_COORDINATE_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::difference_type arg2 ;
  std::vector< COORDINATE >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___setslice__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector___setslice__" "', argument " "2"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoordinateVector___setslice__" "', argument " "3"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< COORDINATE >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::difference_type arg2 ;
  std::vector< COORDINATE >::difference_type arg3 ;
  std::vector< COORDINATE,std::allocator< COORDINATE > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___setslice__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector___setslice__" "', argument " "2"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoordinateVector___setslice__" "', argument " "3"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< COORDINATE >::difference_type >(val3);
  {
    std::vector< COORDINATE,std::allocator< COORDINATE > > *ptr = (std::vector< COORDINATE,std::allocator< COORDINATE > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoordinateVector___setslice__" "', argument " "4"" of type '" "std::vector< COORDINATE,std::allocator< COORDINATE > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector___setslice__" "', argument " "4"" of type '" "std::vector< COORDINATE,std::allocator< COORDINATE > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< COORDINATE,std::allocator< COORDINATE > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CoordinateVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CoordinateVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CoordinateVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CoordinateVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::__setslice__(std::vector< COORDINATE >::difference_type,std::vector< COORDINATE >::difference_type)\n"
    "    std::vector< COORDINATE >::__setslice__(std::vector< COORDINATE >::difference_type,std::vector< COORDINATE >::difference_type,std::vector< COORDINATE,std::allocator< COORDINATE > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::difference_type arg2 ;
  std::vector< COORDINATE >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CoordinateVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___delslice__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector___delslice__" "', argument " "2"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoordinateVector___delslice__" "', argument " "3"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< COORDINATE >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___delitem__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector___delitem__" "', argument " "2"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< COORDINATE,std::allocator< COORDINATE > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___getitem__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< COORDINATE,std::allocator< COORDINATE > > *)std_vector_Sl_COORDINATE_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< COORDINATE,std::allocator< COORDINATE > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___setitem__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< COORDINATE,std::allocator< COORDINATE > > *ptr = (std::vector< COORDINATE,std::allocator< COORDINATE > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoordinateVector___setitem__" "', argument " "3"" of type '" "std::vector< COORDINATE,std::allocator< COORDINATE > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector___setitem__" "', argument " "3"" of type '" "std::vector< COORDINATE,std::allocator< COORDINATE > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< COORDINATE,std::allocator< COORDINATE > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___setitem__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___delitem__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CoordinateVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CoordinateVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CoordinateVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CoordinateVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::__delitem__(std::vector< COORDINATE >::difference_type)\n"
    "    std::vector< COORDINATE >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< COORDINATE >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___getitem__" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector___getitem__" "', argument " "2"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< COORDINATE >::value_type *) &std_vector_Sl_COORDINATE_Sg____getitem____SWIG_1((std::vector< COORDINATE > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< COORDINATE >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CoordinateVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CoordinateVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CoordinateVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CoordinateVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< COORDINATE >::__getitem__(std::vector< COORDINATE >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::difference_type arg2 ;
  std::vector< COORDINATE >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector___setitem__" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector___setitem__" "', argument " "2"" of type '" "std::vector< COORDINATE >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoordinateVector___setitem__" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector___setitem__" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_COORDINATE_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(COORDINATE const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CoordinateVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_CoordinateVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CoordinateVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_COORDINATE, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CoordinateVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CoordinateVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< COORDINATE,std::allocator< COORDINATE > > const &)\n"
    "    std::vector< COORDINATE >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< COORDINATE >::__setitem__(std::vector< COORDINATE >::difference_type,std::vector< COORDINATE >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_pop" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_COORDINATE_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< COORDINATE >::value_type(result)), SWIGTYPE_p_COORDINATE, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CoordinateVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_append" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoordinateVector_append" "', argument " "2"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector_append" "', argument " "2"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_COORDINATE_Sg__append(arg1,(COORDINATE const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoordinateVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< COORDINATE > *)new std::vector< COORDINATE >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoordinateVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< COORDINATE > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< COORDINATE,std::allocator< COORDINATE > > *ptr = (std::vector< COORDINATE,std::allocator< COORDINATE > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_CoordinateVector" "', argument " "1"" of type '" "std::vector< COORDINATE > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CoordinateVector" "', argument " "1"" of type '" "std::vector< COORDINATE > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< COORDINATE > *)new std::vector< COORDINATE >((std::vector< COORDINATE > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_empty" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (bool)((std::vector< COORDINATE > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_size" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = ((std::vector< COORDINATE > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CoordinateVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_swap" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_COORDINATE_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoordinateVector_swap" "', argument " "2"" of type '" "std::vector< COORDINATE > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector_swap" "', argument " "2"" of type '" "std::vector< COORDINATE > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< COORDINATE > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_begin" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< COORDINATE >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_end" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< COORDINATE >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_rbegin" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< COORDINATE >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_rend" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< COORDINATE >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_clear" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< COORDINATE > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_get_allocator" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = ((std::vector< COORDINATE > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< COORDINATE >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_COORDINATE_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoordinateVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< COORDINATE > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CoordinateVector" "', argument " "1"" of type '" "std::vector< COORDINATE >::size_type""'");
  } 
  arg1 = static_cast< std::vector< COORDINATE >::size_type >(val1);
  {
    try {
      result = (std::vector< COORDINATE > *)new std::vector< COORDINATE >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_pop_back" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_resize" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector_resize" "', argument " "2"" of type '" "std::vector< COORDINATE >::size_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< COORDINATE >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_erase" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_erase" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_erase" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_COORDINATE_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< COORDINATE >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::iterator arg2 ;
  std::vector< COORDINATE >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< COORDINATE >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_erase" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_erase" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_erase" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_erase" "', argument " "3"" of type '" "std::vector< COORDINATE >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_erase" "', argument " "3"" of type '" "std::vector< COORDINATE >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_COORDINATE_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< COORDINATE >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CoordinateVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_CoordinateVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_CoordinateVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CoordinateVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::erase(std::vector< COORDINATE >::iterator)\n"
    "    std::vector< COORDINATE >::erase(std::vector< COORDINATE >::iterator,std::vector< COORDINATE >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_CoordinateVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE >::size_type arg1 ;
  std::vector< COORDINATE >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< COORDINATE > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CoordinateVector" "', argument " "1"" of type '" "std::vector< COORDINATE >::size_type""'");
  } 
  arg1 = static_cast< std::vector< COORDINATE >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_CoordinateVector" "', argument " "2"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_CoordinateVector" "', argument " "2"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp2);
  {
    try {
      result = (std::vector< COORDINATE > *)new std::vector< COORDINATE >(SWIG_STD_MOVE(arg1),(std::vector< COORDINATE >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_CoordinateVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_CoordinateVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_CoordinateVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_CoordinateVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CoordinateVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_COORDINATE, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_CoordinateVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_CoordinateVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::vector()\n"
    "    std::vector< COORDINATE >::vector(std::vector< COORDINATE > const &)\n"
    "    std::vector< COORDINATE >::vector(std::vector< COORDINATE >::size_type)\n"
    "    std::vector< COORDINATE >::vector(std::vector< COORDINATE >::size_type,std::vector< COORDINATE >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CoordinateVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_push_back" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CoordinateVector_push_back" "', argument " "2"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector_push_back" "', argument " "2"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< COORDINATE >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_front" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (std::vector< COORDINATE >::value_type *) &((std::vector< COORDINATE > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< COORDINATE >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_back" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = (std::vector< COORDINATE >::value_type *) &((std::vector< COORDINATE > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< COORDINATE >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::size_type arg2 ;
  std::vector< COORDINATE >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:CoordinateVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_assign" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector_assign" "', argument " "2"" of type '" "std::vector< COORDINATE >::size_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoordinateVector_assign" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector_assign" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< COORDINATE >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::size_type arg2 ;
  std::vector< COORDINATE >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_resize" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector_resize" "', argument " "2"" of type '" "std::vector< COORDINATE >::size_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoordinateVector_resize" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector_resize" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< COORDINATE >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CoordinateVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CoordinateVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_COORDINATE, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CoordinateVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CoordinateVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::resize(std::vector< COORDINATE >::size_type)\n"
    "    std::vector< COORDINATE >::resize(std::vector< COORDINATE >::size_type,std::vector< COORDINATE >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::iterator arg2 ;
  std::vector< COORDINATE >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< COORDINATE >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_insert" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_insert" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_insert" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "CoordinateVector_insert" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector_insert" "', argument " "3"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_COORDINATE_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(COORDINATE const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< COORDINATE >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::iterator arg2 ;
  std::vector< COORDINATE >::size_type arg3 ;
  std::vector< COORDINATE >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_insert" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_insert" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "CoordinateVector_insert" "', argument " "2"" of type '" "std::vector< COORDINATE >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "CoordinateVector_insert" "', argument " "3"" of type '" "std::vector< COORDINATE >::size_type""'");
  } 
  arg3 = static_cast< std::vector< COORDINATE >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_COORDINATE,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "CoordinateVector_insert" "', argument " "4"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "CoordinateVector_insert" "', argument " "4"" of type '" "std::vector< COORDINATE >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< COORDINATE >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_COORDINATE_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(COORDINATE const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "CoordinateVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_COORDINATE, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CoordinateVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< COORDINATE,std::allocator< COORDINATE > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< COORDINATE >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_COORDINATE, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CoordinateVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'CoordinateVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< COORDINATE >::insert(std::vector< COORDINATE >::iterator,std::vector< COORDINATE >::value_type const &)\n"
    "    std::vector< COORDINATE >::insert(std::vector< COORDINATE >::iterator,std::vector< COORDINATE >::size_type,std::vector< COORDINATE >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  std::vector< COORDINATE >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:CoordinateVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_reserve" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CoordinateVector_reserve" "', argument " "2"" of type '" "std::vector< COORDINATE >::size_type""'");
  } 
  arg2 = static_cast< std::vector< COORDINATE >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_CoordinateVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< COORDINATE >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CoordinateVector_capacity" "', argument " "1"" of type '" "std::vector< COORDINATE > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      result = ((std::vector< COORDINATE > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_CoordinateVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< COORDINATE > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CoordinateVector" "', argument " "1"" of type '" "std::vector< COORDINATE > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< COORDINATE > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *CoordinateVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_COORDINATE_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *CoordinateVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DoubleDoubleVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_iterator" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_double_Sg__Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_double_Sg__Sg____nonzero__((std::vector< std::vector< double > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___bool__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_double_Sg__Sg____bool__((std::vector< std::vector< double > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___len__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg____len__((std::vector< std::vector< double > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DoubleDoubleVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDoubleVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDoubleVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleDoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleDoubleVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DoubleDoubleVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DoubleDoubleVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleDoubleVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type)\n"
    "    std::vector< std::vector< double > >::__setslice__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DoubleDoubleVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDoubleVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleDoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleDoubleVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoubleDoubleVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleDoubleVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleDoubleVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::__delitem__(std::vector< std::vector< double > >::difference_type)\n"
    "    std::vector< std::vector< double > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< double > >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< double > >::value_type *) &std_vector_Sl_std_vector_Sl_double_Sg__Sg____getitem____SWIG_1((std::vector< std::vector< double > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleDoubleVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoubleDoubleVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleDoubleVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleDoubleVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< double > >::__getitem__(std::vector< std::vector< double > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::difference_type arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< double > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::difference_type >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleDoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_double_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< double,std::allocator< double > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleDoubleVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DoubleDoubleVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoubleDoubleVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoubleDoubleVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleDoubleVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const &)\n"
    "    std::vector< std::vector< double > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< double > >::__setitem__(std::vector< std::vector< double > >::difference_type,std::vector< std::vector< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleDoubleVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_append" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDoubleVector_append" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector_append" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_double_Sg__Sg__append(arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleDoubleVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleDoubleVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::vector< double > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DoubleDoubleVector" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DoubleDoubleVector" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >((std::vector< std::vector< double,std::allocator< double > > > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::vector< double > > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_size" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< double > > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleDoubleVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDoubleVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< double,std::allocator< double > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_end" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< double,std::allocator< double > > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< double > > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< double > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_double_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleDoubleVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::vector< double > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleDoubleVector" "', argument " "1"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::vector< double > >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  std::vector< std::vector< double > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::vector< double > >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleDoubleVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DoubleDoubleVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DoubleDoubleVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleDoubleVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::erase(std::vector< std::vector< double > >::iterator)\n"
    "    std::vector< std::vector< double > >::erase(std::vector< std::vector< double > >::iterator,std::vector< std::vector< double > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DoubleDoubleVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > >::size_type arg1 ;
  std::vector< std::vector< double > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< double > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DoubleDoubleVector" "', argument " "1"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< double > >::size_type >(val1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DoubleDoubleVector" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DoubleDoubleVector" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< double > > *)new std::vector< std::vector< double > >(SWIG_STD_MOVE(arg1),(std::vector< std::vector< double > >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DoubleDoubleVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DoubleDoubleVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DoubleDoubleVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DoubleDoubleVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DoubleDoubleVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DoubleDoubleVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DoubleDoubleVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::vector()\n"
    "    std::vector< std::vector< double > >::vector(std::vector< std::vector< double,std::allocator< double > > > const &)\n"
    "    std::vector< std::vector< double > >::vector(std::vector< std::vector< double > >::size_type)\n"
    "    std::vector< std::vector< double > >::vector(std::vector< std::vector< double > >::size_type,std::vector< std::vector< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleDoubleVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DoubleDoubleVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< double > >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_front" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_back" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< double > >::value_type *) &((std::vector< std::vector< double > > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< double > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DoubleDoubleVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleDoubleVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< std::vector< double > >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleDoubleVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< std::vector< double > >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleDoubleVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DoubleDoubleVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoubleDoubleVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleDoubleVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::resize(std::vector< std::vector< double > >::size_type)\n"
    "    std::vector< std::vector< double > >::resize(std::vector< std::vector< double > >::size_type,std::vector< std::vector< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  std::vector< std::vector< double > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::vector< double > >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DoubleDoubleVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< double,std::allocator< double > > const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< double > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::iterator arg2 ;
  std::vector< std::vector< double > >::size_type arg3 ;
  std::vector< std::vector< double > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DoubleDoubleVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< double > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DoubleDoubleVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< double > >::size_type >(val3);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DoubleDoubleVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DoubleDoubleVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< double > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_double_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< double,std::allocator< double > > const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DoubleDoubleVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DoubleDoubleVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< double > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DoubleDoubleVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DoubleDoubleVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< double > >::insert(std::vector< std::vector< double > >::iterator,std::vector< std::vector< double > >::value_type const &)\n"
    "    std::vector< std::vector< double > >::insert(std::vector< std::vector< double > >::iterator,std::vector< std::vector< double > >::size_type,std::vector< std::vector< double > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  std::vector< std::vector< double > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DoubleDoubleVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DoubleDoubleVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< double > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< double > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DoubleDoubleVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< double > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DoubleDoubleVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< double > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< double > > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DoubleDoubleVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DoubleDoubleVector" "', argument " "1"" of type '" "std::vector< std::vector< double > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< double > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DoubleDoubleVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_double_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DoubleDoubleVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_IntIntVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_iterator" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_std_vector_Sl_int_Sg__Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___nonzero__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_int_Sg__Sg____nonzero__((std::vector< std::vector< int > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___bool__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_std_vector_Sl_int_Sg__Sg____bool__((std::vector< std::vector< int > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___len__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = std_vector_Sl_std_vector_Sl_int_Sg__Sg____len__((std::vector< std::vector< int > > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntIntVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___getslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector___getslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntIntVector___getslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntIntVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___setslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector___setslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntIntVector___setslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  {
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntIntVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector___setslice__" "', argument " "4"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntIntVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_IntIntVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IntIntVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntIntVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__setslice__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::difference_type)\n"
    "    std::vector< std::vector< int > >::__setslice__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntIntVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntIntVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___delslice__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector___delslice__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntIntVector___delslice__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector___delitem__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_0(arg1,arg2,(std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___delitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntIntVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntIntVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntIntVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntIntVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__delitem__(std::vector< std::vector< int > >::difference_type)\n"
    "    std::vector< std::vector< int > >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntIntVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< std::vector< int > >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___getitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector___getitem__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< std::vector< int > >::value_type *) &std_vector_Sl_std_vector_Sl_int_Sg__Sg____getitem____SWIG_1((std::vector< std::vector< int > > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntIntVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntIntVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntIntVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntIntVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< int > >::__getitem__(std::vector< std::vector< int > >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntIntVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::difference_type arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector___setitem__" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector___setitem__" "', argument " "2"" of type '" "std::vector< std::vector< int > >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::difference_type >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector___setitem__" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_int_Sg__Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(std::vector< int,std::allocator< int > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntIntVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_IntIntVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntIntVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntIntVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntIntVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &)\n"
    "    std::vector< std::vector< int > >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< std::vector< int > >::__setitem__(std::vector< std::vector< int > >::difference_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntIntVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_pop" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntIntVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_append" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntIntVector_append" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector_append" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_int_Sg__Sg__append(arg1,(std::vector< int,std::allocator< int > > const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntIntVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntIntVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int,std::allocator< int > > > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< std::vector< int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *ptr = (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_IntIntVector" "', argument " "1"" of type '" "std::vector< std::vector< int,std::allocator< int > > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntIntVector" "', argument " "1"" of type '" "std::vector< std::vector< int,std::allocator< int > > > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >((std::vector< std::vector< int,std::allocator< int > > > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_empty" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (bool)((std::vector< std::vector< int > > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_size" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< int > > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int,std::allocator< int > > > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntIntVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_swap" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntIntVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< int,std::allocator< int > > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector_swap" "', argument " "2"" of type '" "std::vector< std::vector< int,std::allocator< int > > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< std::vector< int,std::allocator< int > > > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_begin" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_end" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_rbegin" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_rend" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_clear" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< std::vector< int,std::allocator< int > > > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_get_allocator" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< int > > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< std::vector< int > >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_std__vectorT_int_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntIntVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< std::vector< int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntIntVector" "', argument " "1"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< int > >::size_type >(val1);
  {
    try {
      result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_pop_back" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< std::vector< int > >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  std::vector< std::vector< int > >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< std::vector< int > >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_erase" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_erase" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_erase" "', argument " "3"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntIntVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_IntIntVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_IntIntVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntIntVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::erase(std::vector< std::vector< int > >::iterator)\n"
    "    std::vector< std::vector< int > >::erase(std::vector< std::vector< int > >::iterator,std::vector< std::vector< int > >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_IntIntVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > >::size_type arg1 ;
  std::vector< std::vector< int > >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  std::vector< std::vector< int > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IntIntVector" "', argument " "1"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg1 = static_cast< std::vector< std::vector< int > >::size_type >(val1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res2 = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_IntIntVector" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_IntIntVector" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      result = (std::vector< std::vector< int > > *)new std::vector< std::vector< int > >(SWIG_STD_MOVE(arg1),(std::vector< std::vector< int > >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_IntIntVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_IntIntVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_IntIntVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_IntIntVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_IntIntVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_IntIntVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_IntIntVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::vector()\n"
    "    std::vector< std::vector< int > >::vector(std::vector< std::vector< int,std::allocator< int > > > const &)\n"
    "    std::vector< std::vector< int > >::vector(std::vector< std::vector< int > >::size_type)\n"
    "    std::vector< std::vector< int > >::vector(std::vector< std::vector< int > >::size_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntIntVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntIntVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_push_back" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res2 = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntIntVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector_push_back" "', argument " "2"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg2 = ptr;
  }
  {
    try {
      (arg1)->push_back((std::vector< std::vector< int > >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_front" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< int > >::value_type *) &((std::vector< std::vector< int > > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_back" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = (std::vector< std::vector< int > >::value_type *) &((std::vector< std::vector< int > > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(*result));
  if (!swig::container_owner<swig::traits<std::vector< std::vector< int > >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:IntIntVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_assign" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector_assign" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntIntVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector_assign" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< std::vector< int > >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_resize" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector_resize" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntIntVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector_resize" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< std::vector< int > >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntIntVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IntIntVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntIntVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntIntVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::resize(std::vector< std::vector< int > >::size_type)\n"
    "    std::vector< std::vector< int > >::resize(std::vector< std::vector< int > >::size_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntIntVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  std::vector< std::vector< int > >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  std::vector< std::vector< int > >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IntIntVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      result = std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(std::vector< int,std::allocator< int > > const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< std::vector< int > >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::iterator arg2 ;
  std::vector< std::vector< int > >::size_type arg3 ;
  std::vector< std::vector< int > >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_insert" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "IntIntVector_insert" "', argument " "2"" of type '" "std::vector< std::vector< int > >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IntIntVector_insert" "', argument " "3"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg3 = static_cast< std::vector< std::vector< int > >::size_type >(val3);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IntIntVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "IntIntVector_insert" "', argument " "4"" of type '" "std::vector< std::vector< int > >::value_type const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      std_vector_Sl_std_vector_Sl_int_Sg__Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< int,std::allocator< int > > const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "IntIntVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntIntVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< std::vector< int > >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< int,std::allocator< int > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_IntIntVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'IntIntVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< std::vector< int > >::insert(std::vector< std::vector< int > >::iterator,std::vector< std::vector< int > >::value_type const &)\n"
    "    std::vector< std::vector< int > >::insert(std::vector< std::vector< int > >::iterator,std::vector< std::vector< int > >::size_type,std::vector< std::vector< int > >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_IntIntVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  std::vector< std::vector< int > >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:IntIntVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_reserve" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IntIntVector_reserve" "', argument " "2"" of type '" "std::vector< std::vector< int > >::size_type""'");
  } 
  arg2 = static_cast< std::vector< std::vector< int > >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_IntIntVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< std::vector< int > >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntIntVector_capacity" "', argument " "1"" of type '" "std::vector< std::vector< int > > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      result = ((std::vector< std::vector< int > > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_IntIntVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< std::vector< int > > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IntIntVector" "', argument " "1"" of type '" "std::vector< std::vector< int > > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< std::vector< int > > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *IntIntVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_std__vectorT_int_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *IntIntVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_ElemProbVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_iterator" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_vrna_ep_t_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___nonzero__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_ep_t_Sg____nonzero__((std::vector< vrna_ep_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___bool__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_ep_t_Sg____bool__((std::vector< vrna_ep_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___len__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = std_vector_Sl_vrna_ep_t_Sg____len__((std::vector< vrna_ep_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::difference_type arg2 ;
  std::vector< vrna_ep_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElemProbVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___getslice__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector___getslice__" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ElemProbVector___getslice__" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_ep_t >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)std_vector_Sl_vrna_ep_t_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::difference_type arg2 ;
  std::vector< vrna_ep_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ElemProbVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_ep_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::difference_type arg2 ;
  std::vector< vrna_ep_t >::difference_type arg3 ;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ElemProbVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_ep_t >::difference_type >(val3);
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElemProbVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ElemProbVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ElemProbVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ElemProbVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElemProbVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::__setslice__(std::vector< vrna_ep_t >::difference_type,std::vector< vrna_ep_t >::difference_type)\n"
    "    std::vector< vrna_ep_t >::__setslice__(std::vector< vrna_ep_t >::difference_type,std::vector< vrna_ep_t >::difference_type,std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::difference_type arg2 ;
  std::vector< vrna_ep_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElemProbVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___delslice__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector___delslice__" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ElemProbVector___delslice__" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_ep_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector___delitem__" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)std_vector_Sl_vrna_ep_t_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElemProbVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ElemProbVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ElemProbVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ElemProbVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElemProbVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::__delitem__(std::vector< vrna_ep_t >::difference_type)\n"
    "    std::vector< vrna_ep_t >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< vrna_ep_t >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector___getitem__" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< vrna_ep_t >::value_type *) &std_vector_Sl_vrna_ep_t_Sg____getitem____SWIG_1((std::vector< vrna_ep_t > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_ep_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ElemProbVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ElemProbVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ElemProbVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElemProbVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_ep_t >::__getitem__(std::vector< vrna_ep_t >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::difference_type arg2 ;
  std::vector< vrna_ep_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector___setitem__" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElemProbVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_vrna_ep_t_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(vrna_ep_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ElemProbVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_ElemProbVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ElemProbVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ElemProbVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElemProbVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > const &)\n"
    "    std::vector< vrna_ep_t >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_ep_t >::__setitem__(std::vector< vrna_ep_t >::difference_type,std::vector< vrna_ep_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< vrna_ep_t > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_pop" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_vrna_ep_t_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_ep_t >::value_type(result)), SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElemProbVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_append" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElemProbVector_append" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector_append" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_vrna_ep_t_Sg__append(arg1,(vrna_ep_t const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ElemProbVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< vrna_ep_t > *)new std::vector< vrna_ep_t >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ElemProbVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< vrna_ep_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ElemProbVector" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ElemProbVector" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< vrna_ep_t > *)new std::vector< vrna_ep_t >((std::vector< vrna_ep_t > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_empty" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (bool)((std::vector< vrna_ep_t > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_size" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_ep_t > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElemProbVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_swap" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_vrna_ep_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElemProbVector_swap" "', argument " "2"" of type '" "std::vector< vrna_ep_t > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector_swap" "', argument " "2"" of type '" "std::vector< vrna_ep_t > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_begin" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_ep_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_end" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_ep_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_rbegin" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_ep_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_rend" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_ep_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_clear" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< vrna_ep_t > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_get_allocator" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_ep_t > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_ep_t >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_vrna_ep_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ElemProbVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< vrna_ep_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ElemProbVector" "', argument " "1"" of type '" "std::vector< vrna_ep_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_ep_t >::size_type >(val1);
  {
    try {
      result = (std::vector< vrna_ep_t > *)new std::vector< vrna_ep_t >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_pop_back" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_resize" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector_resize" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< vrna_ep_t >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_erase" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_erase" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_erase" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_ep_t_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_ep_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::iterator arg2 ;
  std::vector< vrna_ep_t >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< vrna_ep_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_erase" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_erase" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_erase" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_erase" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_erase" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_ep_t_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_ep_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ElemProbVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_ElemProbVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_ElemProbVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElemProbVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::erase(std::vector< vrna_ep_t >::iterator)\n"
    "    std::vector< vrna_ep_t >::erase(std::vector< vrna_ep_t >::iterator,std::vector< vrna_ep_t >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_ElemProbVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t >::size_type arg1 ;
  std::vector< vrna_ep_t >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< vrna_ep_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ElemProbVector" "', argument " "1"" of type '" "std::vector< vrna_ep_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_ep_t >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_ElemProbVector" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_ElemProbVector" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp2);
  {
    try {
      result = (std::vector< vrna_ep_t > *)new std::vector< vrna_ep_t >(SWIG_STD_MOVE(arg1),(std::vector< vrna_ep_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ElemProbVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_ElemProbVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_ElemProbVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_ElemProbVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ElemProbVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_ElemProbVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_ElemProbVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::vector()\n"
    "    std::vector< vrna_ep_t >::vector(std::vector< vrna_ep_t > const &)\n"
    "    std::vector< vrna_ep_t >::vector(std::vector< vrna_ep_t >::size_type)\n"
    "    std::vector< vrna_ep_t >::vector(std::vector< vrna_ep_t >::size_type,std::vector< vrna_ep_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElemProbVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_push_back" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ElemProbVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< vrna_ep_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_front" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_ep_t >::value_type *) &((std::vector< vrna_ep_t > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_ep_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_back" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_ep_t >::value_type *) &((std::vector< vrna_ep_t > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_ep_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::size_type arg2 ;
  std::vector< vrna_ep_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ElemProbVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_assign" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector_assign" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElemProbVector_assign" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector_assign" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< vrna_ep_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::size_type arg2 ;
  std::vector< vrna_ep_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_resize" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector_resize" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElemProbVector_resize" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector_resize" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< vrna_ep_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ElemProbVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ElemProbVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ElemProbVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElemProbVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::resize(std::vector< vrna_ep_t >::size_type)\n"
    "    std::vector< vrna_ep_t >::resize(std::vector< vrna_ep_t >::size_type,std::vector< vrna_ep_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::iterator arg2 ;
  std::vector< vrna_ep_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< vrna_ep_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_insert" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_insert" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_insert" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ElemProbVector_insert" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector_insert" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_vrna_ep_t_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(vrna_ep_t const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_ep_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::iterator arg2 ;
  std::vector< vrna_ep_t >::size_type arg3 ;
  std::vector< vrna_ep_t >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_insert" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_insert" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "ElemProbVector_insert" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ElemProbVector_insert" "', argument " "3"" of type '" "std::vector< vrna_ep_t >::size_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_ep_t >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_vrna_ep_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ElemProbVector_insert" "', argument " "4"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "ElemProbVector_insert" "', argument " "4"" of type '" "std::vector< vrna_ep_t >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< vrna_ep_t >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_vrna_ep_t_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(vrna_ep_t const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "ElemProbVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ElemProbVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_ep_t >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ElemProbVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ElemProbVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_ep_t >::insert(std::vector< vrna_ep_t >::iterator,std::vector< vrna_ep_t >::value_type const &)\n"
    "    std::vector< vrna_ep_t >::insert(std::vector< vrna_ep_t >::iterator,std::vector< vrna_ep_t >::size_type,std::vector< vrna_ep_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  std::vector< vrna_ep_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:ElemProbVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_reserve" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ElemProbVector_reserve" "', argument " "2"" of type '" "std::vector< vrna_ep_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_ep_t >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ElemProbVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_ep_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ElemProbVector_capacity" "', argument " "1"" of type '" "std::vector< vrna_ep_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_ep_t > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ElemProbVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ElemProbVector" "', argument " "1"" of type '" "std::vector< vrna_ep_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_ep_t > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ElemProbVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_vrna_ep_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ElemProbVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_HelixVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_iterator" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_vrna_hx_t_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___nonzero__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_hx_t_Sg____nonzero__((std::vector< vrna_hx_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___bool__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_hx_t_Sg____bool__((std::vector< vrna_hx_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___len__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = std_vector_Sl_vrna_hx_t_Sg____len__((std::vector< vrna_hx_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::difference_type arg2 ;
  std::vector< vrna_hx_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HelixVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___getslice__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector___getslice__" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelixVector___getslice__" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_hx_t >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *)std_vector_Sl_vrna_hx_t_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::difference_type arg2 ;
  std::vector< vrna_hx_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelixVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_hx_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::difference_type arg2 ;
  std::vector< vrna_hx_t >::difference_type arg3 ;
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelixVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_hx_t >::difference_type >(val3);
  {
    std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *ptr = (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HelixVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HelixVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_HelixVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HelixVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HelixVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::__setslice__(std::vector< vrna_hx_t >::difference_type,std::vector< vrna_hx_t >::difference_type)\n"
    "    std::vector< vrna_hx_t >::__setslice__(std::vector< vrna_hx_t >::difference_type,std::vector< vrna_hx_t >::difference_type,std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelixVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::difference_type arg2 ;
  std::vector< vrna_hx_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HelixVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___delslice__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector___delslice__" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelixVector___delslice__" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_hx_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector___delitem__" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *)std_vector_Sl_vrna_hx_t_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *ptr = (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelixVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HelixVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HelixVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HelixVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HelixVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::__delitem__(std::vector< vrna_hx_t >::difference_type)\n"
    "    std::vector< vrna_hx_t >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelixVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< vrna_hx_t >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector___getitem__" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< vrna_hx_t >::value_type *) &std_vector_Sl_vrna_hx_t_Sg____getitem____SWIG_1((std::vector< vrna_hx_t > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_hx_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HelixVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HelixVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HelixVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HelixVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_hx_t >::__getitem__(std::vector< vrna_hx_t >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelixVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::difference_type arg2 ;
  std::vector< vrna_hx_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector___setitem__" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelixVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_vrna_hx_t_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(vrna_hx_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HelixVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HelixVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HelixVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HelixVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HelixVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > const &)\n"
    "    std::vector< vrna_hx_t >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_hx_t >::__setitem__(std::vector< vrna_hx_t >::difference_type,std::vector< vrna_hx_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelixVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< vrna_hx_t > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_pop" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_vrna_hx_t_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_hx_t >::value_type(result)), SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HelixVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_append" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelixVector_append" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector_append" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_vrna_hx_t_Sg__append(arg1,(vrna_hx_t const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelixVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< vrna_hx_t > *)new std::vector< vrna_hx_t >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelixVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< vrna_hx_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *ptr = (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HelixVector" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HelixVector" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< vrna_hx_t > *)new std::vector< vrna_hx_t >((std::vector< vrna_hx_t > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_empty" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (bool)((std::vector< vrna_hx_t > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_size" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_hx_t > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HelixVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_swap" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_vrna_hx_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelixVector_swap" "', argument " "2"" of type '" "std::vector< vrna_hx_t > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector_swap" "', argument " "2"" of type '" "std::vector< vrna_hx_t > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_begin" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_hx_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_end" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_hx_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_rbegin" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_hx_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_rend" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_hx_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_clear" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< vrna_hx_t > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_get_allocator" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_hx_t > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_hx_t >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_vrna_hx_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelixVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< vrna_hx_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelixVector" "', argument " "1"" of type '" "std::vector< vrna_hx_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_hx_t >::size_type >(val1);
  {
    try {
      result = (std::vector< vrna_hx_t > *)new std::vector< vrna_hx_t >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_pop_back" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_resize" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector_resize" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< vrna_hx_t >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_erase" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_erase" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_erase" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_hx_t_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_hx_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::iterator arg2 ;
  std::vector< vrna_hx_t >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< vrna_hx_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_erase" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_erase" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_erase" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_erase" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_erase" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_hx_t_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_hx_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HelixVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_HelixVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_HelixVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HelixVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::erase(std::vector< vrna_hx_t >::iterator)\n"
    "    std::vector< vrna_hx_t >::erase(std::vector< vrna_hx_t >::iterator,std::vector< vrna_hx_t >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_HelixVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t >::size_type arg1 ;
  std::vector< vrna_hx_t >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< vrna_hx_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HelixVector" "', argument " "1"" of type '" "std::vector< vrna_hx_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_hx_t >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HelixVector" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HelixVector" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp2);
  {
    try {
      result = (std::vector< vrna_hx_t > *)new std::vector< vrna_hx_t >(SWIG_STD_MOVE(arg1),(std::vector< vrna_hx_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HelixVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HelixVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_HelixVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_HelixVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HelixVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_HelixVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HelixVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::vector()\n"
    "    std::vector< vrna_hx_t >::vector(std::vector< vrna_hx_t > const &)\n"
    "    std::vector< vrna_hx_t >::vector(std::vector< vrna_hx_t >::size_type)\n"
    "    std::vector< vrna_hx_t >::vector(std::vector< vrna_hx_t >::size_type,std::vector< vrna_hx_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelixVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HelixVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_push_back" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HelixVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< vrna_hx_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_front" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_hx_t >::value_type *) &((std::vector< vrna_hx_t > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_hx_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_back" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_hx_t >::value_type *) &((std::vector< vrna_hx_t > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_hx_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::size_type arg2 ;
  std::vector< vrna_hx_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HelixVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_assign" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector_assign" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelixVector_assign" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector_assign" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< vrna_hx_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::size_type arg2 ;
  std::vector< vrna_hx_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_resize" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector_resize" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelixVector_resize" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector_resize" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< vrna_hx_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HelixVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HelixVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HelixVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HelixVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::resize(std::vector< vrna_hx_t >::size_type)\n"
    "    std::vector< vrna_hx_t >::resize(std::vector< vrna_hx_t >::size_type,std::vector< vrna_hx_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelixVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::iterator arg2 ;
  std::vector< vrna_hx_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< vrna_hx_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_insert" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_insert" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_insert" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HelixVector_insert" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector_insert" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_vrna_hx_t_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(vrna_hx_t const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_hx_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::iterator arg2 ;
  std::vector< vrna_hx_t >::size_type arg3 ;
  std::vector< vrna_hx_t >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_insert" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_insert" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HelixVector_insert" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HelixVector_insert" "', argument " "3"" of type '" "std::vector< vrna_hx_t >::size_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_hx_t >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_vrna_hx_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HelixVector_insert" "', argument " "4"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HelixVector_insert" "', argument " "4"" of type '" "std::vector< vrna_hx_t >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< vrna_hx_t >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_vrna_hx_t_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(vrna_hx_t const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HelixVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HelixVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_hx_t >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HelixVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HelixVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_hx_t >::insert(std::vector< vrna_hx_t >::iterator,std::vector< vrna_hx_t >::value_type const &)\n"
    "    std::vector< vrna_hx_t >::insert(std::vector< vrna_hx_t >::iterator,std::vector< vrna_hx_t >::size_type,std::vector< vrna_hx_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HelixVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  std::vector< vrna_hx_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HelixVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_reserve" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HelixVector_reserve" "', argument " "2"" of type '" "std::vector< vrna_hx_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_hx_t >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HelixVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_hx_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HelixVector_capacity" "', argument " "1"" of type '" "std::vector< vrna_hx_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_hx_t > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HelixVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HelixVector" "', argument " "1"" of type '" "std::vector< vrna_hx_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_hx_t > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HelixVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_vrna_hx_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HelixVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_PathVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_iterator" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_vrna_path_t_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___nonzero__" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_path_t_Sg____nonzero__((std::vector< vrna_path_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___bool__" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_path_t_Sg____bool__((std::vector< vrna_path_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___len__" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = std_vector_Sl_vrna_path_t_Sg____len__((std::vector< vrna_path_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::difference_type arg2 ;
  std::vector< vrna_path_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< vrna_path_t,std::allocator< vrna_path_t > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PathVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___getslice__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector___getslice__" "', argument " "2"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PathVector___getslice__" "', argument " "3"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_path_t >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< vrna_path_t,std::allocator< vrna_path_t > > *)std_vector_Sl_vrna_path_t_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::difference_type arg2 ;
  std::vector< vrna_path_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PathVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_path_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::difference_type arg2 ;
  std::vector< vrna_path_t >::difference_type arg3 ;
  std::vector< vrna_path_t,std::allocator< vrna_path_t > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PathVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_path_t >::difference_type >(val3);
  {
    std::vector< vrna_path_t,std::allocator< vrna_path_t > > *ptr = (std::vector< vrna_path_t,std::allocator< vrna_path_t > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PathVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PathVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PathVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PathVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PathVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::__setslice__(std::vector< vrna_path_t >::difference_type,std::vector< vrna_path_t >::difference_type)\n"
    "    std::vector< vrna_path_t >::__setslice__(std::vector< vrna_path_t >::difference_type,std::vector< vrna_path_t >::difference_type,std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PathVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::difference_type arg2 ;
  std::vector< vrna_path_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PathVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___delslice__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector___delslice__" "', argument " "2"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PathVector___delslice__" "', argument " "3"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_path_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector___delitem__" "', argument " "2"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< vrna_path_t,std::allocator< vrna_path_t > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< vrna_path_t,std::allocator< vrna_path_t > > *)std_vector_Sl_vrna_path_t_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< vrna_path_t,std::allocator< vrna_path_t > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< vrna_path_t,std::allocator< vrna_path_t > > *ptr = (std::vector< vrna_path_t,std::allocator< vrna_path_t > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PathVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PathVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_PathVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PathVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PathVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::__delitem__(std::vector< vrna_path_t >::difference_type)\n"
    "    std::vector< vrna_path_t >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PathVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< vrna_path_t >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector___getitem__" "', argument " "2"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< vrna_path_t >::value_type *) &std_vector_Sl_vrna_path_t_Sg____getitem____SWIG_1((std::vector< vrna_path_t > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_path_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PathVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_PathVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PathVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PathVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_path_t >::__getitem__(std::vector< vrna_path_t >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PathVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::difference_type arg2 ;
  std::vector< vrna_path_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector___setitem__" "', argument " "2"" of type '" "std::vector< vrna_path_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PathVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_vrna_path_t_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(vrna_path_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PathVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_PathVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PathVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_path_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PathVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PathVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< vrna_path_t,std::allocator< vrna_path_t > > const &)\n"
    "    std::vector< vrna_path_t >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_path_t >::__setitem__(std::vector< vrna_path_t >::difference_type,std::vector< vrna_path_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PathVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< vrna_path_t > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_pop" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_vrna_path_t_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_path_t >::value_type(result)), SWIGTYPE_p_vrna_path_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PathVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_append" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PathVector_append" "', argument " "2"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector_append" "', argument " "2"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_vrna_path_t_Sg__append(arg1,(vrna_path_t const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PathVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< vrna_path_t > *)new std::vector< vrna_path_t >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PathVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< vrna_path_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< vrna_path_t,std::allocator< vrna_path_t > > *ptr = (std::vector< vrna_path_t,std::allocator< vrna_path_t > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PathVector" "', argument " "1"" of type '" "std::vector< vrna_path_t > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PathVector" "', argument " "1"" of type '" "std::vector< vrna_path_t > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< vrna_path_t > *)new std::vector< vrna_path_t >((std::vector< vrna_path_t > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_empty" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (bool)((std::vector< vrna_path_t > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_size" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_path_t > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PathVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_swap" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_vrna_path_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PathVector_swap" "', argument " "2"" of type '" "std::vector< vrna_path_t > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector_swap" "', argument " "2"" of type '" "std::vector< vrna_path_t > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_path_t > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_begin" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_path_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_end" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_path_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_rbegin" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_path_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_rend" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_path_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_clear" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< vrna_path_t > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_get_allocator" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_path_t > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_path_t >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_vrna_path_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PathVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< vrna_path_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PathVector" "', argument " "1"" of type '" "std::vector< vrna_path_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_path_t >::size_type >(val1);
  {
    try {
      result = (std::vector< vrna_path_t > *)new std::vector< vrna_path_t >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_pop_back" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_resize" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector_resize" "', argument " "2"" of type '" "std::vector< vrna_path_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< vrna_path_t >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_erase" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_erase" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_erase" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_path_t_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_path_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::iterator arg2 ;
  std::vector< vrna_path_t >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< vrna_path_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_erase" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_erase" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_erase" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_erase" "', argument " "3"" of type '" "std::vector< vrna_path_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_erase" "', argument " "3"" of type '" "std::vector< vrna_path_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_path_t_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_path_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PathVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_PathVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_PathVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PathVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::erase(std::vector< vrna_path_t >::iterator)\n"
    "    std::vector< vrna_path_t >::erase(std::vector< vrna_path_t >::iterator,std::vector< vrna_path_t >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_PathVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t >::size_type arg1 ;
  std::vector< vrna_path_t >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< vrna_path_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PathVector" "', argument " "1"" of type '" "std::vector< vrna_path_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_path_t >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_PathVector" "', argument " "2"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_PathVector" "', argument " "2"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp2);
  {
    try {
      result = (std::vector< vrna_path_t > *)new std::vector< vrna_path_t >(SWIG_STD_MOVE(arg1),(std::vector< vrna_path_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_PathVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_PathVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_PathVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_PathVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PathVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_vrna_path_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_PathVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_PathVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::vector()\n"
    "    std::vector< vrna_path_t >::vector(std::vector< vrna_path_t > const &)\n"
    "    std::vector< vrna_path_t >::vector(std::vector< vrna_path_t >::size_type)\n"
    "    std::vector< vrna_path_t >::vector(std::vector< vrna_path_t >::size_type,std::vector< vrna_path_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PathVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PathVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_push_back" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PathVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< vrna_path_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_front" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_path_t >::value_type *) &((std::vector< vrna_path_t > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_path_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_back" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_path_t >::value_type *) &((std::vector< vrna_path_t > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_path_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::size_type arg2 ;
  std::vector< vrna_path_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PathVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_assign" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector_assign" "', argument " "2"" of type '" "std::vector< vrna_path_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PathVector_assign" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector_assign" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< vrna_path_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::size_type arg2 ;
  std::vector< vrna_path_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_resize" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector_resize" "', argument " "2"" of type '" "std::vector< vrna_path_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PathVector_resize" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector_resize" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< vrna_path_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PathVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PathVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_path_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PathVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PathVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::resize(std::vector< vrna_path_t >::size_type)\n"
    "    std::vector< vrna_path_t >::resize(std::vector< vrna_path_t >::size_type,std::vector< vrna_path_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PathVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::iterator arg2 ;
  std::vector< vrna_path_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< vrna_path_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_insert" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_insert" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_insert" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PathVector_insert" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector_insert" "', argument " "3"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_vrna_path_t_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(vrna_path_t const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_path_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::iterator arg2 ;
  std::vector< vrna_path_t >::size_type arg3 ;
  std::vector< vrna_path_t >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_insert" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_insert" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "PathVector_insert" "', argument " "2"" of type '" "std::vector< vrna_path_t >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PathVector_insert" "', argument " "3"" of type '" "std::vector< vrna_path_t >::size_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_path_t >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_vrna_path_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PathVector_insert" "', argument " "4"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "PathVector_insert" "', argument " "4"" of type '" "std::vector< vrna_path_t >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< vrna_path_t >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_vrna_path_t_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(vrna_path_t const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "PathVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_path_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PathVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_path_t,std::allocator< vrna_path_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_path_t >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_vrna_path_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PathVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'PathVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_path_t >::insert(std::vector< vrna_path_t >::iterator,std::vector< vrna_path_t >::value_type const &)\n"
    "    std::vector< vrna_path_t >::insert(std::vector< vrna_path_t >::iterator,std::vector< vrna_path_t >::size_type,std::vector< vrna_path_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_PathVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  std::vector< vrna_path_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PathVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_reserve" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PathVector_reserve" "', argument " "2"" of type '" "std::vector< vrna_path_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_path_t >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PathVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_path_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PathVector_capacity" "', argument " "1"" of type '" "std::vector< vrna_path_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_path_t > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_PathVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_path_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PathVector" "', argument " "1"" of type '" "std::vector< vrna_path_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_path_t > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *PathVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_vrna_path_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *PathVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_MoveVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_iterator" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_vrna_move_t_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___nonzero__" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_move_t_Sg____nonzero__((std::vector< vrna_move_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___bool__" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_vrna_move_t_Sg____bool__((std::vector< vrna_move_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___len__" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = std_vector_Sl_vrna_move_t_Sg____len__((std::vector< vrna_move_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::difference_type arg2 ;
  std::vector< vrna_move_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MoveVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___getslice__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector___getslice__" "', argument " "2"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MoveVector___getslice__" "', argument " "3"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_move_t >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< vrna_move_t,std::allocator< vrna_move_t > > *)std_vector_Sl_vrna_move_t_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::difference_type arg2 ;
  std::vector< vrna_move_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MoveVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_move_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::difference_type arg2 ;
  std::vector< vrna_move_t >::difference_type arg3 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___setslice__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector___setslice__" "', argument " "2"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MoveVector___setslice__" "', argument " "3"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_move_t >::difference_type >(val3);
  {
    std::vector< vrna_move_t,std::allocator< vrna_move_t > > *ptr = (std::vector< vrna_move_t,std::allocator< vrna_move_t > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MoveVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector___setslice__" "', argument " "4"" of type '" "std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MoveVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MoveVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MoveVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MoveVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::__setslice__(std::vector< vrna_move_t >::difference_type,std::vector< vrna_move_t >::difference_type)\n"
    "    std::vector< vrna_move_t >::__setslice__(std::vector< vrna_move_t >::difference_type,std::vector< vrna_move_t >::difference_type,std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoveVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::difference_type arg2 ;
  std::vector< vrna_move_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MoveVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___delslice__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector___delslice__" "', argument " "2"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MoveVector___delslice__" "', argument " "3"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_move_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector___delitem__" "', argument " "2"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< vrna_move_t,std::allocator< vrna_move_t > > *)std_vector_Sl_vrna_move_t_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< vrna_move_t,std::allocator< vrna_move_t > > *ptr = (std::vector< vrna_move_t,std::allocator< vrna_move_t > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MoveVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___delitem__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MoveVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_MoveVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MoveVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MoveVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::__delitem__(std::vector< vrna_move_t >::difference_type)\n"
    "    std::vector< vrna_move_t >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoveVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< vrna_move_t >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___getitem__" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector___getitem__" "', argument " "2"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< vrna_move_t >::value_type *) &std_vector_Sl_vrna_move_t_Sg____getitem____SWIG_1((std::vector< vrna_move_t > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_move_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MoveVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_MoveVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MoveVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MoveVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_move_t >::__getitem__(std::vector< vrna_move_t >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoveVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::difference_type arg2 ;
  std::vector< vrna_move_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector___setitem__" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector___setitem__" "', argument " "2"" of type '" "std::vector< vrna_move_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MoveVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector___setitem__" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_vrna_move_t_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(vrna_move_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MoveVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_MoveVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MoveVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_move_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MoveVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MoveVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< vrna_move_t,std::allocator< vrna_move_t > > const &)\n"
    "    std::vector< vrna_move_t >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< vrna_move_t >::__setitem__(std::vector< vrna_move_t >::difference_type,std::vector< vrna_move_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoveVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< vrna_move_t > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_pop" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_vrna_move_t_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_move_t >::value_type(result)), SWIGTYPE_p_vrna_move_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MoveVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_append" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MoveVector_append" "', argument " "2"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector_append" "', argument " "2"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_vrna_move_t_Sg__append(arg1,(vrna_move_t const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoveVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< vrna_move_t > *)new std::vector< vrna_move_t >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoveVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< vrna_move_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< vrna_move_t,std::allocator< vrna_move_t > > *ptr = (std::vector< vrna_move_t,std::allocator< vrna_move_t > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MoveVector" "', argument " "1"" of type '" "std::vector< vrna_move_t > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MoveVector" "', argument " "1"" of type '" "std::vector< vrna_move_t > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< vrna_move_t > *)new std::vector< vrna_move_t >((std::vector< vrna_move_t > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_empty" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (bool)((std::vector< vrna_move_t > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_size" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_move_t > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MoveVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_swap" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_vrna_move_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MoveVector_swap" "', argument " "2"" of type '" "std::vector< vrna_move_t > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector_swap" "', argument " "2"" of type '" "std::vector< vrna_move_t > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_move_t > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_begin" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_move_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_end" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_move_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_rbegin" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_move_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_rend" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_move_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_clear" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< vrna_move_t > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_get_allocator" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_move_t > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< vrna_move_t >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_vrna_move_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoveVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< vrna_move_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MoveVector" "', argument " "1"" of type '" "std::vector< vrna_move_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_move_t >::size_type >(val1);
  {
    try {
      result = (std::vector< vrna_move_t > *)new std::vector< vrna_move_t >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_pop_back" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_resize" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector_resize" "', argument " "2"" of type '" "std::vector< vrna_move_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< vrna_move_t >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_erase" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_erase" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_erase" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_move_t_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_move_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::iterator arg2 ;
  std::vector< vrna_move_t >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< vrna_move_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_erase" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_erase" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_erase" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_erase" "', argument " "3"" of type '" "std::vector< vrna_move_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_erase" "', argument " "3"" of type '" "std::vector< vrna_move_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_vrna_move_t_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_move_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MoveVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_MoveVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_MoveVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MoveVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::erase(std::vector< vrna_move_t >::iterator)\n"
    "    std::vector< vrna_move_t >::erase(std::vector< vrna_move_t >::iterator,std::vector< vrna_move_t >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_MoveVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t >::size_type arg1 ;
  std::vector< vrna_move_t >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< vrna_move_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MoveVector" "', argument " "1"" of type '" "std::vector< vrna_move_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< vrna_move_t >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MoveVector" "', argument " "2"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_MoveVector" "', argument " "2"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp2);
  {
    try {
      result = (std::vector< vrna_move_t > *)new std::vector< vrna_move_t >(SWIG_STD_MOVE(arg1),(std::vector< vrna_move_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_MoveVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_MoveVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_MoveVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MoveVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MoveVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_vrna_move_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MoveVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_MoveVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::vector()\n"
    "    std::vector< vrna_move_t >::vector(std::vector< vrna_move_t > const &)\n"
    "    std::vector< vrna_move_t >::vector(std::vector< vrna_move_t >::size_type)\n"
    "    std::vector< vrna_move_t >::vector(std::vector< vrna_move_t >::size_type,std::vector< vrna_move_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoveVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MoveVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_push_back" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MoveVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector_push_back" "', argument " "2"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< vrna_move_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_front" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_move_t >::value_type *) &((std::vector< vrna_move_t > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_move_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_back" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = (std::vector< vrna_move_t >::value_type *) &((std::vector< vrna_move_t > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< vrna_move_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::size_type arg2 ;
  std::vector< vrna_move_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:MoveVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_assign" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector_assign" "', argument " "2"" of type '" "std::vector< vrna_move_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MoveVector_assign" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector_assign" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< vrna_move_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::size_type arg2 ;
  std::vector< vrna_move_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_resize" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector_resize" "', argument " "2"" of type '" "std::vector< vrna_move_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MoveVector_resize" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector_resize" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< vrna_move_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MoveVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MoveVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_move_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MoveVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MoveVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::resize(std::vector< vrna_move_t >::size_type)\n"
    "    std::vector< vrna_move_t >::resize(std::vector< vrna_move_t >::size_type,std::vector< vrna_move_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoveVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::iterator arg2 ;
  std::vector< vrna_move_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< vrna_move_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_insert" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_insert" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_insert" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MoveVector_insert" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector_insert" "', argument " "3"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_vrna_move_t_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(vrna_move_t const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< vrna_move_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::iterator arg2 ;
  std::vector< vrna_move_t >::size_type arg3 ;
  std::vector< vrna_move_t >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_insert" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_insert" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "MoveVector_insert" "', argument " "2"" of type '" "std::vector< vrna_move_t >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MoveVector_insert" "', argument " "3"" of type '" "std::vector< vrna_move_t >::size_type""'");
  } 
  arg3 = static_cast< std::vector< vrna_move_t >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_vrna_move_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MoveVector_insert" "', argument " "4"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "MoveVector_insert" "', argument " "4"" of type '" "std::vector< vrna_move_t >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< vrna_move_t >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_vrna_move_t_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(vrna_move_t const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MoveVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_move_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MoveVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_move_t,std::allocator< vrna_move_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< vrna_move_t >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_vrna_move_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MoveVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MoveVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< vrna_move_t >::insert(std::vector< vrna_move_t >::iterator,std::vector< vrna_move_t >::value_type const &)\n"
    "    std::vector< vrna_move_t >::insert(std::vector< vrna_move_t >::iterator,std::vector< vrna_move_t >::size_type,std::vector< vrna_move_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_MoveVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  std::vector< vrna_move_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:MoveVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_reserve" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MoveVector_reserve" "', argument " "2"" of type '" "std::vector< vrna_move_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< vrna_move_t >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MoveVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< vrna_move_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveVector_capacity" "', argument " "1"" of type '" "std::vector< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      result = ((std::vector< vrna_move_t > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_MoveVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MoveVector" "', argument " "1"" of type '" "std::vector< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< vrna_move_t > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *MoveVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_vrna_move_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *MoveVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_varArrayUChar(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< unsigned char,std::allocator< unsigned char > > > arg1 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"d",  (char *)"type",  NULL 
  };
  var_array< unsigned char > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_varArrayUChar", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_varArrayUChar" "', argument " "1"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_varArrayUChar" "', argument " "1"" of type '" "std::vector< unsigned char,std::allocator< unsigned char > >""'");
    } else {
      std::vector< unsigned char,std::allocator< unsigned char > > * temp = reinterpret_cast< std::vector< unsigned char,std::allocator< unsigned char > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayUChar" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (var_array< unsigned char > *)new_var_array_Sl_unsigned_SS_char_Sg_(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_char_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_varArrayUChar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_varArrayUChar" "', argument " "1"" of type '" "var_array< unsigned char > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  {
    try {
      delete_var_array_Sl_unsigned_SS_char_Sg_(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUChar_type" "', argument " "1"" of type '" "var_array< unsigned char > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  {
    try {
      result = var_array_Sl_unsigned_SS_char_Sg__type(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUChar_size" "', argument " "1"" of type '" "var_array< unsigned char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  {
    try {
      result = var_array_Sl_unsigned_SS_char_Sg__size((var_array< unsigned char > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUChar___len__" "', argument " "1"" of type '" "var_array< unsigned char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  {
    try {
      result = var_array_Sl_unsigned_SS_char_Sg____len__((var_array< unsigned char > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  unsigned char result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:varArrayUChar_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUChar_get" "', argument " "1"" of type '" "var_array< unsigned char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayUChar_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (unsigned char)var_array_Sl_unsigned_SS_char_Sg__get((var_array< unsigned char > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUChar___getitem__" "', argument " "1"" of type '" "var_array< unsigned char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayUChar___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (unsigned char)var_array_Sl_unsigned_SS_char_Sg____getitem____SWIG_0((var_array< unsigned char > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  int arg2 ;
  unsigned char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  NULL 
  };
  unsigned char result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:varArrayUChar___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUChar___setitem__" "', argument " "1"" of type '" "var_array< unsigned char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayUChar___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "varArrayUChar___setitem__" "', argument " "3"" of type '" "unsigned char""'");
  } 
  arg3 = static_cast< unsigned char >(val3);
  {
    try {
      try {
        result = (unsigned char)var_array_Sl_unsigned_SS_char_Sg____setitem__((var_array< unsigned char > const *)arg1,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< unsigned char > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< unsigned char > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUChar___getitem__" "', argument " "1"" of type '" "var_array< unsigned char > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned char > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "varArrayUChar___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      result = (var_array< unsigned char > *)var_array_Sl_unsigned_SS_char_Sg____getitem____SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_char_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUChar___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "varArrayUChar___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_unsigned_char_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_varArrayUChar___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_unsigned_char_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_varArrayUChar___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'varArrayUChar___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< unsigned char >::__getitem__(int) const\n"
    "    var_array< unsigned char >::__getitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *varArrayUChar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_var_arrayT_unsigned_char_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *varArrayUChar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_varArrayChar(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< char,std::allocator< char > > > arg1 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"d",  (char *)"type",  NULL 
  };
  var_array< char > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_varArrayChar", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_std__vectorT_char_std__allocatorT_char_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_varArrayChar" "', argument " "1"" of type '" "std::vector< char,std::allocator< char > >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_varArrayChar" "', argument " "1"" of type '" "std::vector< char,std::allocator< char > >""'");
    } else {
      std::vector< char,std::allocator< char > > * temp = reinterpret_cast< std::vector< char,std::allocator< char > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayChar" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (var_array< char > *)new_var_array_Sl_char_Sg_(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_char_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_varArrayChar(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_char_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_varArrayChar" "', argument " "1"" of type '" "var_array< char > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  {
    try {
      delete_var_array_Sl_char_Sg_(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayChar_type" "', argument " "1"" of type '" "var_array< char > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  {
    try {
      result = var_array_Sl_char_Sg__type(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayChar_size" "', argument " "1"" of type '" "var_array< char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  {
    try {
      result = var_array_Sl_char_Sg__size((var_array< char > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayChar___len__" "', argument " "1"" of type '" "var_array< char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  {
    try {
      result = var_array_Sl_char_Sg____len__((var_array< char > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  char result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:varArrayChar_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayChar_get" "', argument " "1"" of type '" "var_array< char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayChar_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (char)var_array_Sl_char_Sg__get((var_array< char > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayChar___getitem__" "', argument " "1"" of type '" "var_array< char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayChar___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (char)var_array_Sl_char_Sg____getitem____SWIG_0((var_array< char > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  int arg2 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  NULL 
  };
  char result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:varArrayChar___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayChar___setitem__" "', argument " "1"" of type '" "var_array< char > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayChar___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_char(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "varArrayChar___setitem__" "', argument " "3"" of type '" "char""'");
  } 
  arg3 = static_cast< char >(val3);
  {
    try {
      try {
        result = (char)var_array_Sl_char_Sg____setitem__((var_array< char > const *)arg1,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< char > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< char > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_char_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayChar___getitem__" "', argument " "1"" of type '" "var_array< char > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< char > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "varArrayChar___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      result = (var_array< char > *)var_array_Sl_char_Sg____getitem____SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_char_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayChar___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "varArrayChar___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_char_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_varArrayChar___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_char_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_varArrayChar___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'varArrayChar___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< char >::__getitem__(int) const\n"
    "    var_array< char >::__getitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *varArrayChar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_var_arrayT_char_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *varArrayChar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_varArrayShort__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  SwigValueWrapper< std::vector< short,std::allocator< short > > > arg1 ;
  unsigned int arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  var_array< short > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t,  0  | 0);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_varArrayShort" "', argument " "1"" of type '" "std::vector< short,std::allocator< short > >""'"); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_varArrayShort" "', argument " "1"" of type '" "std::vector< short,std::allocator< short > >""'");
    } else {
      std::vector< short,std::allocator< short > > * temp = reinterpret_cast< std::vector< short,std::allocator< short > > * >(argp1);
      arg1 = *temp;
      if (SWIG_IsNewObj(res1)) delete temp;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayShort" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (var_array< short > *)new_var_array_Sl_short_Sg___SWIG_0(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_varArrayShort(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_varArrayShort" "', argument " "1"" of type '" "var_array< short > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    try {
      delete_var_array_Sl_short_Sg_(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayShort_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayShort_type" "', argument " "1"" of type '" "var_array< short > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    try {
      result = var_array_Sl_short_Sg__type(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayShort_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayShort_size" "', argument " "1"" of type '" "var_array< short > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    try {
      result = var_array_Sl_short_Sg__size((var_array< short > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayShort___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayShort___len__" "', argument " "1"" of type '" "var_array< short > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    try {
      result = var_array_Sl_short_Sg____len__((var_array< short > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayShort_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  short result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:varArrayShort_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayShort_get" "', argument " "1"" of type '" "var_array< short > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayShort_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (short)var_array_Sl_short_Sg__get((var_array< short > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayShort___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayShort___getitem__" "', argument " "1"" of type '" "var_array< short > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayShort___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (short)var_array_Sl_short_Sg____getitem____SWIG_0((var_array< short > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayShort___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  int arg2 ;
  short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  NULL 
  };
  short result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:varArrayShort___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayShort___setitem__" "', argument " "1"" of type '" "var_array< short > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayShort___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "varArrayShort___setitem__" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  {
    try {
      try {
        result = (short)var_array_Sl_short_Sg____setitem__((var_array< short > const *)arg1,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_varArrayShort__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  unsigned int arg2 = VAR_ARRAY_LINEAR|VAR_ARRAY_ONE_BASED ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  var_array< short > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_varArrayShort" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayShort" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (var_array< short > *)new_var_array_Sl_short_Sg___SWIG_1(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_varArrayShort(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_varArrayShort", 0, 2, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_varArrayShort__SWIG_1(self, argc, argv);
      }
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_varArrayShort__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_std__vectorT_short_std__allocatorT_short_t_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_varArrayShort__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_varArrayShort'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< short >::var_array(std::vector< short,std::allocator< short > >,unsigned int)\n"
    "    var_array< short >::var_array(std::vector< int,std::allocator< int > >,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_varArrayShort___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< short > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayShort___getitem__" "', argument " "1"" of type '" "var_array< short > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "varArrayShort___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      result = (var_array< short > *)var_array_Sl_short_Sg____getitem____SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayShort___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "varArrayShort___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_short_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_varArrayShort___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_short_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_varArrayShort___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'varArrayShort___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< short >::__getitem__(int) const\n"
    "    var_array< short >::__getitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *varArrayShort_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_var_arrayT_short_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *varArrayShort_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_varArrayUInt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > arg1 ;
  unsigned int arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"d",  (char *)"type",  NULL 
  };
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_varArrayUInt", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_varArrayUInt" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayUInt" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (var_array< unsigned int > *)new_var_array_Sl_unsigned_SS_int_Sg_(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_varArrayUInt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_varArrayUInt" "', argument " "1"" of type '" "var_array< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  {
    try {
      delete_var_array_Sl_unsigned_SS_int_Sg_(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUInt_type" "', argument " "1"" of type '" "var_array< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  {
    try {
      result = var_array_Sl_unsigned_SS_int_Sg__type(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUInt_size" "', argument " "1"" of type '" "var_array< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  {
    try {
      result = var_array_Sl_unsigned_SS_int_Sg__size((var_array< unsigned int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUInt___len__" "', argument " "1"" of type '" "var_array< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  {
    try {
      result = var_array_Sl_unsigned_SS_int_Sg____len__((var_array< unsigned int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:varArrayUInt_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUInt_get" "', argument " "1"" of type '" "var_array< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayUInt_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (unsigned int)var_array_Sl_unsigned_SS_int_Sg__get((var_array< unsigned int > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUInt___getitem__" "', argument " "1"" of type '" "var_array< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayUInt___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (unsigned int)var_array_Sl_unsigned_SS_int_Sg____getitem____SWIG_0((var_array< unsigned int > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:varArrayUInt___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUInt___setitem__" "', argument " "1"" of type '" "var_array< unsigned int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayUInt___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "varArrayUInt___setitem__" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      try {
        result = (unsigned int)var_array_Sl_unsigned_SS_int_Sg____setitem__((var_array< unsigned int > const *)arg1,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< unsigned int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayUInt___getitem__" "', argument " "1"" of type '" "var_array< unsigned int > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< unsigned int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "varArrayUInt___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      result = (var_array< unsigned int > *)var_array_Sl_unsigned_SS_int_Sg____getitem____SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayUInt___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "varArrayUInt___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_unsigned_int_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_varArrayUInt___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_unsigned_int_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_varArrayUInt___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'varArrayUInt___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< unsigned int >::__getitem__(int) const\n"
    "    var_array< unsigned int >::__getitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *varArrayUInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_var_arrayT_unsigned_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *varArrayUInt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_varArrayInt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  unsigned int arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"d",  (char *)"type",  NULL 
  };
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_varArrayInt", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_varArrayInt" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayInt" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (var_array< int > *)new_var_array_Sl_int_Sg_(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_varArrayInt(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_int_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_varArrayInt" "', argument " "1"" of type '" "var_array< int > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  {
    try {
      delete_var_array_Sl_int_Sg_(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayInt_type" "', argument " "1"" of type '" "var_array< int > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  {
    try {
      result = var_array_Sl_int_Sg__type(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayInt_size" "', argument " "1"" of type '" "var_array< int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  {
    try {
      result = var_array_Sl_int_Sg__size((var_array< int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayInt___len__" "', argument " "1"" of type '" "var_array< int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  {
    try {
      result = var_array_Sl_int_Sg____len__((var_array< int > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:varArrayInt_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayInt_get" "', argument " "1"" of type '" "var_array< int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayInt_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (int)var_array_Sl_int_Sg__get((var_array< int > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayInt___getitem__" "', argument " "1"" of type '" "var_array< int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayInt___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (int)var_array_Sl_int_Sg____getitem____SWIG_0((var_array< int > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:varArrayInt___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayInt___setitem__" "', argument " "1"" of type '" "var_array< int > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayInt___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "varArrayInt___setitem__" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      try {
        result = (int)var_array_Sl_int_Sg____setitem__((var_array< int > const *)arg1,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< int > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayInt___getitem__" "', argument " "1"" of type '" "var_array< int > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< int > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "varArrayInt___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      result = (var_array< int > *)var_array_Sl_int_Sg____getitem____SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayInt___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "varArrayInt___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_int_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_varArrayInt___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_int_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_varArrayInt___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'varArrayInt___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< int >::__getitem__(int) const\n"
    "    var_array< int >::__getitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *varArrayInt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_var_arrayT_int_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *varArrayInt_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_varArrayFLTorDBL(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< FLT_OR_DBL,std::allocator< FLT_OR_DBL > > arg1 ;
  unsigned int arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"d",  (char *)"type",  NULL 
  };
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_varArrayFLTorDBL", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_varArrayFLTorDBL" "', argument " "1"" of type '" "std::vector< FLT_OR_DBL,std::allocator< FLT_OR_DBL > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayFLTorDBL" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)new_var_array_Sl_FLT_OR_DBL_Sg_(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_varArrayFLTorDBL(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_varArrayFLTorDBL" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  {
    try {
      delete_var_array_Sl_FLT_OR_DBL_Sg_(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayFLTorDBL_type" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  {
    try {
      result = var_array_Sl_FLT_OR_DBL_Sg__type(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayFLTorDBL_size" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  {
    try {
      result = var_array_Sl_FLT_OR_DBL_Sg__size((var_array< FLT_OR_DBL > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayFLTorDBL___len__" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  {
    try {
      result = var_array_Sl_FLT_OR_DBL_Sg____len__((var_array< FLT_OR_DBL > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:varArrayFLTorDBL_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayFLTorDBL_get" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayFLTorDBL_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (FLT_OR_DBL)var_array_Sl_FLT_OR_DBL_Sg__get((var_array< FLT_OR_DBL > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  FLT_OR_DBL result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayFLTorDBL___getitem__" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayFLTorDBL___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = (FLT_OR_DBL)var_array_Sl_FLT_OR_DBL_Sg____getitem____SWIG_0((var_array< FLT_OR_DBL > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  int arg2 ;
  FLT_OR_DBL arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:varArrayFLTorDBL___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayFLTorDBL___setitem__" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayFLTorDBL___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "varArrayFLTorDBL___setitem__" "', argument " "3"" of type '" "FLT_OR_DBL""'");
  } 
  arg3 = static_cast< FLT_OR_DBL >(val3);
  {
    try {
      try {
        result = (FLT_OR_DBL)var_array_Sl_FLT_OR_DBL_Sg____setitem__((var_array< FLT_OR_DBL > const *)arg1,arg2,arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< FLT_OR_DBL > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayFLTorDBL___getitem__" "', argument " "1"" of type '" "var_array< FLT_OR_DBL > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< FLT_OR_DBL > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "varArrayFLTorDBL___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      result = (var_array< FLT_OR_DBL > *)var_array_Sl_FLT_OR_DBL_Sg____getitem____SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayFLTorDBL___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "varArrayFLTorDBL___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_varArrayFLTorDBL___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_varArrayFLTorDBL___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'varArrayFLTorDBL___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< FLT_OR_DBL >::__getitem__(int) const\n"
    "    var_array< FLT_OR_DBL >::__getitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *varArrayFLTorDBL_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *varArrayFLTorDBL_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_varArrayMove(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > arg1 ;
  unsigned int arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"d",  (char *)"type",  NULL 
  };
  var_array< vrna_move_t > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:new_varArrayMove", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< vrna_move_t,std::allocator< vrna_move_t > > *ptr = (std::vector< vrna_move_t,std::allocator< vrna_move_t > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_varArrayMove" "', argument " "1"" of type '" "std::vector< vrna_move_t,std::allocator< vrna_move_t > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_varArrayMove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (var_array< vrna_move_t > *)new_var_array_Sl_vrna_move_t_Sg_(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_vrna_move_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_varArrayMove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_varArrayMove" "', argument " "1"" of type '" "var_array< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  {
    try {
      delete_var_array_Sl_vrna_move_t_Sg_(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove_type(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayMove_type" "', argument " "1"" of type '" "var_array< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  {
    try {
      result = var_array_Sl_vrna_move_t_Sg__type(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayMove_size" "', argument " "1"" of type '" "var_array< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  {
    try {
      result = var_array_Sl_vrna_move_t_Sg__size((var_array< vrna_move_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  size_t result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayMove___len__" "', argument " "1"" of type '" "var_array< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  {
    try {
      result = var_array_Sl_vrna_move_t_Sg____len__((var_array< vrna_move_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  SwigValueWrapper< vrna_move_t > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:varArrayMove_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayMove_get" "', argument " "1"" of type '" "var_array< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayMove_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = var_array_Sl_vrna_move_t_Sg__get((var_array< vrna_move_t > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new vrna_move_t(result)), SWIGTYPE_p_vrna_move_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< vrna_move_t > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayMove___getitem__" "', argument " "1"" of type '" "var_array< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayMove___getitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      try {
        result = var_array_Sl_vrna_move_t_Sg____getitem____SWIG_0((var_array< vrna_move_t > const *)arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new vrna_move_t(result)), SWIGTYPE_p_vrna_move_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove___setitem__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  int arg2 ;
  SwigValueWrapper< vrna_move_t > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  NULL 
  };
  SwigValueWrapper< vrna_move_t > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:varArrayMove___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayMove___setitem__" "', argument " "1"" of type '" "var_array< vrna_move_t > const *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "varArrayMove___setitem__" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_vrna_move_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "varArrayMove___setitem__" "', argument " "3"" of type '" "vrna_move_t const""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "varArrayMove___setitem__" "', argument " "3"" of type '" "vrna_move_t const""'");
    } else {
      vrna_move_t * temp = reinterpret_cast< vrna_move_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  {
    try {
      try {
        result = var_array_Sl_vrna_move_t_Sg____setitem__((var_array< vrna_move_t > const *)arg1,arg2,SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new vrna_move_t(result)), SWIGTYPE_p_vrna_move_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< vrna_move_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< vrna_move_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "varArrayMove___getitem__" "', argument " "1"" of type '" "var_array< vrna_move_t > *""'"); 
  }
  arg1 = reinterpret_cast< var_array< vrna_move_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "varArrayMove___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      result = (var_array< vrna_move_t > *)var_array_Sl_vrna_move_t_Sg____getitem____SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_vrna_move_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_varArrayMove___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "varArrayMove___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_varArrayMove___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_var_arrayT_vrna_move_t_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_varArrayMove___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'varArrayMove___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    var_array< vrna_move_t >::__getitem__(int) const\n"
    "    var_array< vrna_move_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *varArrayMove_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_var_arrayT_vrna_move_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *varArrayMove_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_basepair_i_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_basepair_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "basepair_i_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_basepair_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "basepair_i_set" "', argument " "1"" of type '" "vrna_basepair_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_basepair_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "basepair_i_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->i = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_basepair_i_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_basepair_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_basepair_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "basepair_i_get" "', argument " "1"" of type '" "vrna_basepair_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_basepair_t * >(argp1);
  result = (int) ((arg1)->i);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_basepair_j_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_basepair_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "basepair_j_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_basepair_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "basepair_j_set" "', argument " "1"" of type '" "vrna_basepair_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_basepair_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "basepair_j_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->j = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_basepair_j_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_basepair_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_basepair_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "basepair_j_get" "', argument " "1"" of type '" "vrna_basepair_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_basepair_t * >(argp1);
  result = (int) ((arg1)->j);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_basepair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_basepair_t *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_basepair", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_basepair_t *)new vrna_basepair_t();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_basepair_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_basepair(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_basepair_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_basepair_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_basepair" "', argument " "1"" of type '" "vrna_basepair_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_basepair_t * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *basepair_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_basepair_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *basepair_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_duplexT_i_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_i_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_i_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_i_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->i = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_i_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_i_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->i);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_j_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_j_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_j_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_j_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->j = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_j_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_j_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->j);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_end_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_end_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->end = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_end_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->end);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_structure_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_structure_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_structure_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "duplexT_structure_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->structure;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->structure = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->structure = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_structure_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_structure_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (char *) ((arg1)->structure);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_energy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_energy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_energy_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_energy_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->energy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_energy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_energy_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (double) ((arg1)->energy);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_energy_backtrack_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_energy_backtrack_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_energy_backtrack_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_energy_backtrack_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->energy_backtrack = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_energy_backtrack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_energy_backtrack_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (double) ((arg1)->energy_backtrack);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_opening_backtrack_x_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_opening_backtrack_x_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_opening_backtrack_x_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_opening_backtrack_x_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->opening_backtrack_x = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_opening_backtrack_x_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_opening_backtrack_x_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (double) ((arg1)->opening_backtrack_x);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_opening_backtrack_y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_opening_backtrack_y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_opening_backtrack_y_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_opening_backtrack_y_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->opening_backtrack_y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_opening_backtrack_y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_opening_backtrack_y_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (double) ((arg1)->opening_backtrack_y);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_offset_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_offset_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_offset_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_offset_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->offset = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_offset_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_offset_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->offset);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_dG1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_dG1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_dG1_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_dG1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->dG1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_dG1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_dG1_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (double) ((arg1)->dG1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_dG2_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_dG2_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_dG2_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_dG2_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->dG2 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_dG2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_dG2_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (double) ((arg1)->dG2);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_ddG_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_ddG_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_ddG_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_ddG_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->ddG = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_ddG_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_ddG_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (double) ((arg1)->ddG);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_tb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_tb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_tb_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_tb_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->tb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_tb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_tb_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->tb);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_te_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_te_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_te_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_te_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->te = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_te_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_te_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->te);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_qb_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_qb_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_qb_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_qb_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->qb = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_qb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_qb_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->qb);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_qe_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplexT_qe_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_qe_set" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplexT_qe_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->qe = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplexT_qe_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplexT_qe_get" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  result = (int) ((arg1)->qe);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_duplexT(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplexT *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplexT, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_duplexT" "', argument " "1"" of type '" "duplexT *""'"); 
  }
  arg1 = reinterpret_cast< duplexT * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *duplexT_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_duplexT, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_param_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_id_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->id);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_stack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[NBPAIRS+1] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_stack_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[NBPAIRS+1])(int (*)[NBPAIRS+1]) ((arg1)->stack);
  {
    size_t i, j;
    //result, NBPAIRS+1, NBPAIRS+1
    resultobj = PyList_New(NBPAIRS+1);
    for (i = 0; i < NBPAIRS+1; i++) {
      PyObject *l = PyList_New(NBPAIRS+1);
      for (j = 0; j < NBPAIRS+1; j++) {
        PyObject *o = PyLong_FromLong((long) result[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(resultobj,i,l);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_hairpin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_hairpin_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->hairpin);
  {
    int i;
    resultobj = PyList_New(31);
    for (i = 0; i < 31; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_bulge_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_bulge_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->bulge);
  {
    int i;
    resultobj = PyList_New(MAXLOOP+1);
    for (i = 0; i < MAXLOOP+1; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_internal_loop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_internal_loop_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->internal_loop);
  {
    int i;
    resultobj = PyList_New(MAXLOOP+1);
    for (i = 0; i < MAXLOOP+1; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_mismatchExt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_mismatchExt_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5][5])(int (*)[5][5]) ((arg1)->mismatchExt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_mismatchI_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_mismatchI_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5][5])(int (*)[5][5]) ((arg1)->mismatchI);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_mismatch1nI_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_mismatch1nI_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5][5])(int (*)[5][5]) ((arg1)->mismatch1nI);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_mismatch23I_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_mismatch23I_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5][5])(int (*)[5][5]) ((arg1)->mismatch23I);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_mismatchH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_mismatchH_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5][5])(int (*)[5][5]) ((arg1)->mismatchH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_mismatchM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_mismatchM_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5][5])(int (*)[5][5]) ((arg1)->mismatchM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_dangle5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_dangle5_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5])(int (*)[5]) ((arg1)->dangle5);
  {
    size_t i, j;
    //result, NBPAIRS+1, 5
    resultobj = PyList_New(NBPAIRS+1);
    for (i = 0; i < NBPAIRS+1; i++) {
      PyObject *l = PyList_New(5);
      for (j = 0; j < 5; j++) {
        PyObject *o = PyLong_FromLong((long) result[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(resultobj,i,l);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_dangle3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_dangle3_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[5])(int (*)[5]) ((arg1)->dangle3);
  {
    size_t i, j;
    //result, NBPAIRS+1, 5
    resultobj = PyList_New(NBPAIRS+1);
    for (i = 0; i < NBPAIRS+1; i++) {
      PyObject *l = PyList_New(5);
      for (j = 0; j < 5; j++) {
        PyObject *o = PyLong_FromLong((long) result[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(resultobj,i,l);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_int11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[NBPAIRS+1][5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_int11_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[NBPAIRS+1][5][5])(int (*)[NBPAIRS+1][5][5]) ((arg1)->int11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_int21_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[NBPAIRS+1][5][5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_int21_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[NBPAIRS+1][5][5][5])(int (*)[NBPAIRS+1][5][5][5]) ((arg1)->int21);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_int22_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[NBPAIRS+1][5][5][5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_int22_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[NBPAIRS+1][5][5][5][5])(int (*)[NBPAIRS+1][5][5][5][5]) ((arg1)->int22);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_ninio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_ninio_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->ninio);
  {
    int i;
    resultobj = PyList_New(5);
    for (i = 0; i < 5; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_lxc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_lxc_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (double)(double) ((arg1)->lxc);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_MLbase_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_MLbase_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->MLbase);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_MLintern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_MLintern_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->MLintern);
  {
    int i;
    resultobj = PyList_New(NBPAIRS+1);
    for (i = 0; i < NBPAIRS+1; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_MLclosing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_MLclosing_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->MLclosing);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_TerminalAU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_TerminalAU_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->TerminalAU);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_DuplexInit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_DuplexInit_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->DuplexInit);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_Tetraloop_E_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_Tetraloop_E_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->Tetraloop_E);
  {
    int i;
    resultobj = PyList_New(200);
    for (i = 0; i < 200; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_Tetraloops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_Tetraloops_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->Tetraloops);
  {
    size_t size = SWIG_strnlen(result, 1401);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_Triloop_E_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_Triloop_E_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->Triloop_E);
  {
    int i;
    resultobj = PyList_New(40);
    for (i = 0; i < 40; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_Triloops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_Triloops_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->Triloops);
  {
    size_t size = SWIG_strnlen(result, 241);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_Hexaloop_E_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_Hexaloop_E_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->Hexaloop_E);
  {
    int i;
    resultobj = PyList_New(40);
    for (i = 0; i < 40; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_Hexaloops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_Hexaloops_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->Hexaloops);
  {
    size_t size = SWIG_strnlen(result, 1801);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_TripleC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_TripleC_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->TripleC);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_MultipleCA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_MultipleCA_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->MultipleCA);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_MultipleCB_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_MultipleCB_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->MultipleCB);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_gquad_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_gquad_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int (*)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1])(int (*)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1]) ((arg1)->gquad);
  {
    size_t i, j;
    //result, VRNA_GQUAD_MAX_STACK_SIZE+1, 3*VRNA_GQUAD_MAX_LINKER_LENGTH+1
    resultobj = PyList_New(VRNA_GQUAD_MAX_STACK_SIZE+1);
    for (i = 0; i < VRNA_GQUAD_MAX_STACK_SIZE+1; i++) {
      PyObject *l = PyList_New(3*VRNA_GQUAD_MAX_LINKER_LENGTH+1);
      for (j = 0; j < 3*VRNA_GQUAD_MAX_LINKER_LENGTH+1; j++) {
        PyObject *o = PyLong_FromLong((long) result[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(resultobj,i,l);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_gquadLayerMismatch_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_gquadLayerMismatch_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->gquadLayerMismatch);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_gquadLayerMismatchMax_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_gquadLayerMismatchMax_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->gquadLayerMismatchMax);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_temperature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_temperature_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (double)(double) ((arg1)->temperature);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_model_details_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_md_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_model_details_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (vrna_md_t *)& ((arg1)->model_details);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_md_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_param_file_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_param_file_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->param_file);
  {
    size_t size = SWIG_strnlen(result, 256);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_SaltStack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_SaltStack_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltStack);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_SaltLoop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_SaltLoop_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int *)(int *) ((arg1)->SaltLoop);
  {
    int i;
    resultobj = PyList_New(MAXLOOP+2);
    for (i = 0; i < MAXLOOP+2; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_SaltLoopDbl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_SaltLoopDbl_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->SaltLoopDbl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_SaltMLbase_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_SaltMLbase_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltMLbase);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_SaltMLintern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_SaltMLintern_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltMLintern);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_SaltMLclosing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_SaltMLclosing_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltMLclosing);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param_SaltDPXInit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param_SaltDPXInit_get" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltDPXInit);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_param(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"model_details",  NULL 
  };
  vrna_param_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_param", kwnames, &obj0)) SWIG_fail;
  if (obj0) {
    res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_param" "', argument " "1"" of type '" "vrna_md_t *""'"); 
    }
    arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  }
  {
    try {
      result = (vrna_param_t *)new_vrna_param_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_param_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_param(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_param" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  {
    try {
      delete_vrna_param_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_param___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "param___str__" "', argument " "1"" of type '" "vrna_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_param_t * >(argp1);
  {
    try {
      result = vrna_param_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *param_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_param_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *param_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_exp_param_id_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_id_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (int)(int) ((arg1)->id);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expstack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[NBPAIRS+1] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expstack_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[NBPAIRS+1])(double (*)[NBPAIRS+1]) ((arg1)->expstack);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_NBPAIRS_1__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_exphairpin_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_exphairpin_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->exphairpin);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expbulge_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expbulge_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->expbulge);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expinternal_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expinternal_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->expinternal);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expmismatchExt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expmismatchExt_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5][5])(double (*)[5][5]) ((arg1)->expmismatchExt);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expmismatchI_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expmismatchI_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5][5])(double (*)[5][5]) ((arg1)->expmismatchI);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expmismatch23I_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expmismatch23I_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5][5])(double (*)[5][5]) ((arg1)->expmismatch23I);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expmismatch1nI_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expmismatch1nI_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5][5])(double (*)[5][5]) ((arg1)->expmismatch1nI);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expmismatchH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expmismatchH_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5][5])(double (*)[5][5]) ((arg1)->expmismatchH);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expmismatchM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expmismatchM_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5][5])(double (*)[5][5]) ((arg1)->expmismatchM);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expdangle5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expdangle5_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5])(double (*)[5]) ((arg1)->expdangle5);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expdangle3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expdangle3_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[5])(double (*)[5]) ((arg1)->expdangle3);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expint11_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[NBPAIRS+1][5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expint11_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[NBPAIRS+1][5][5])(double (*)[NBPAIRS+1][5][5]) ((arg1)->expint11);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expint21_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[NBPAIRS+1][5][5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expint21_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[NBPAIRS+1][5][5][5])(double (*)[NBPAIRS+1][5][5][5]) ((arg1)->expint21);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expint22_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[NBPAIRS+1][5][5][5][5] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expint22_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[NBPAIRS+1][5][5][5][5])(double (*)[NBPAIRS+1][5][5][5][5]) ((arg1)->expint22);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expninio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[MAXLOOP+1] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expninio_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[MAXLOOP+1])(double (*)[MAXLOOP+1]) ((arg1)->expninio);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_MAXLOOP_1__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_lxc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_lxc_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->lxc);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expMLbase_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expMLbase_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expMLbase);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expMLintern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expMLintern_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->expMLintern);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expMLclosing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expMLclosing_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expMLclosing);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expTermAU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expTermAU_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expTermAU);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expDuplexInit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expDuplexInit_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expDuplexInit);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_exptetra_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_exptetra_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->exptetra);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_exptri_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_exptri_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->exptri);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_exphex_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_exphex_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->exphex);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_Tetraloops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_Tetraloops_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->Tetraloops);
  {
    size_t size = SWIG_strnlen(result, 1401);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expTriloop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expTriloop_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->expTriloop);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_Triloops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_Triloops_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->Triloops);
  {
    size_t size = SWIG_strnlen(result, 241);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_Hexaloops_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_Hexaloops_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->Hexaloops);
  {
    size_t size = SWIG_strnlen(result, 1801);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expTripleC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expTripleC_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expTripleC);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expMultipleCA_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expMultipleCA_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expMultipleCA);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expMultipleCB_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expMultipleCB_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expMultipleCB);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expgquad_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double (*result)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expgquad_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double (*)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1])(double (*)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1]) ((arg1)->expgquad);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expgquadLayerMismatch_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expgquadLayerMismatch_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expgquadLayerMismatch);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_gquadLayerMismatchMax_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_gquadLayerMismatchMax_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (int)(int) ((arg1)->gquadLayerMismatchMax);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_kT_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_kT_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->kT);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_pf_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_pf_scale_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->pf_scale);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_temperature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_temperature_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->temperature);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_alpha_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_alpha_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->alpha);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_model_details_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_md_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_model_details_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (vrna_md_t *)& ((arg1)->model_details);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_md_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_param_file_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_param_file_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (char *)(char *) ((arg1)->param_file);
  {
    size_t size = SWIG_strnlen(result, 256);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expSaltStack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expSaltStack_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double)(double) ((arg1)->expSaltStack);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_expSaltLoop_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_expSaltLoop_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->expSaltLoop);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_SaltLoopDbl_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_SaltLoopDbl_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (double *)(double *) ((arg1)->SaltLoopDbl);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_SaltMLbase_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_SaltMLbase_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltMLbase);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_SaltMLintern_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_SaltMLintern_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltMLintern);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_SaltMLclosing_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_SaltMLclosing_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltMLclosing);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param_SaltDPXInit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param_SaltDPXInit_get" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  result = (int)(int) ((arg1)->SaltDPXInit);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_exp_param(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"model_details",  NULL 
  };
  vrna_exp_param_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|O:new_exp_param", kwnames, &obj0)) SWIG_fail;
  if (obj0) {
    res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_exp_param" "', argument " "1"" of type '" "vrna_md_t *""'"); 
    }
    arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  }
  {
    try {
      result = (vrna_exp_param_t *)new_vrna_exp_param_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_exp_param_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_exp_param(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_exp_param" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  {
    try {
      delete_vrna_exp_param_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_param___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_exp_param_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "exp_param___str__" "', argument " "1"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_exp_param_t * >(argp1);
  {
    try {
      result = vrna_exp_param_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *exp_param_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_exp_param_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *exp_param_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_params_load(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 = "" ;
  unsigned int arg2 = VRNA_PARAMETER_FORMAT_DEFAULT ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:params_load", kwnames, &obj0, &obj1)) SWIG_fail;
  if (obj0) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj0, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "params_load" "', argument " "1"" of type '" "std::string""'"); 
      }
      arg1 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "params_load" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (int)my_params_load(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_save(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 = VRNA_PARAMETER_FORMAT_DEFAULT ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:params_save", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "params_save" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "params_save" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (int)my_params_save(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_from_string(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 = "" ;
  unsigned int arg3 = VRNA_PARAMETER_FORMAT_DEFAULT ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"parameters",  (char *)"name",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:params_load_from_string", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "params_load_from_string" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj1, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "params_load_from_string" "', argument " "2"" of type '" "std::string""'"); 
      }
      arg2 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "params_load_from_string" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)my_params_load_from_string(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_RNA_Turner2004(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "params_load_RNA_Turner2004", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_params_load_RNA_Turner2004();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_RNA_Turner1999(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "params_load_RNA_Turner1999", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_params_load_RNA_Turner1999();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_RNA_Andronescu2007(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "params_load_RNA_Andronescu2007", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_params_load_RNA_Andronescu2007();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_RNA_Langdon2018(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "params_load_RNA_Langdon2018", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_params_load_RNA_Langdon2018();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_RNA_misc_special_hairpins(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "params_load_RNA_misc_special_hairpins", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_params_load_RNA_misc_special_hairpins();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_DNA_Mathews2004(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "params_load_DNA_Mathews2004", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_params_load_DNA_Mathews2004();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_params_load_DNA_Mathews1999(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "params_load_DNA_Mathews1999", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_params_load_DNA_Mathews1999();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_last_parameter_file(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  char *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "last_parameter_file", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (char *)last_parameter_file();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_read_parameter_file(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"fname",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:read_parameter_file", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "read_parameter_file" "', argument " "1"" of type '" "char const []""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      read_parameter_file((char const (*))arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_write_parameter_file(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = (char *)0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"fname",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:write_parameter_file", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "write_parameter_file" "', argument " "1"" of type '" "char const []""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      write_parameter_file((char const (*))arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_gettype(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"ident",  NULL 
  };
  enum parset result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:gettype", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gettype" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (enum parset)gettype((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_settype(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  enum parset arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"s",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:settype", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "settype" "', argument " "1"" of type '" "enum parset""'");
  } 
  arg1 = static_cast< enum parset >(val1);
  {
    try {
      result = (char *)settype(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_salt_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"L",  (char *)"salt",  (char *)"T",  (char *)"backbonelen",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:salt_loop", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "salt_loop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "salt_loop" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "salt_loop" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "salt_loop" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      result = (double)vrna_salt_loop(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_salt_loop_int(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"L",  (char *)"salt",  (char *)"T",  (char *)"backbonelen",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:salt_loop_int", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "salt_loop_int" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "salt_loop_int" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "salt_loop_int" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "salt_loop_int" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      result = (int)vrna_salt_loop_int(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_salt_stack(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"salt",  (char *)"T",  (char *)"hrise",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:salt_stack", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "salt_stack" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "salt_stack" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "salt_stack" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (int)vrna_salt_stack(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_salt_ml(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double *arg1 = (double *)0 ;
  int arg2 ;
  int arg3 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"saltLoop",  (char *)"lower",  (char *)"upper",  (char *)"m",  (char *)"b",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:salt_ml", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "salt_ml" "', argument " "1"" of type '" "double []""'"); 
  } 
  arg1 = reinterpret_cast< double * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "salt_ml" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "salt_ml" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "salt_ml" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "salt_ml" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  {
    try {
      vrna_salt_ml(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_salt_duplex_init(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"md",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:salt_duplex_init", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "salt_duplex_init" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  {
    try {
      result = (int)vrna_salt_duplex_init(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_lxc37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable lxc37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_lxc37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(lxc37));
  return pyobj;
}


SWIGINTERN int Swig_var_stack37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable stack37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_stack37_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t i, j;
    //stack37, 7+1, 7+1
    pyobj = PyList_New(7+1);
    for (i = 0; i < 7+1; i++) {
      PyObject *l = PyList_New(7+1);
      for (j = 0; j < 7+1; j++) {
        PyObject *o = PyLong_FromLong((long) stack37[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(pyobj,i,l);
    }
  }
  return pyobj;
}


SWIGINTERN int Swig_var_stackdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable stackdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_stackdH_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t i, j;
    //stackdH, 7+1, 7+1
    pyobj = PyList_New(7+1);
    for (i = 0; i < 7+1; i++) {
      PyObject *l = PyList_New(7+1);
      for (j = 0; j < 7+1; j++) {
        PyObject *o = PyLong_FromLong((long) stackdH[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(pyobj,i,l);
    }
  }
  return pyobj;
}


SWIGINTERN int Swig_var_hairpin37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable hairpin37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_hairpin37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(hairpin37), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_hairpindH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable hairpindH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_hairpindH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(hairpindH), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_bulge37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable bulge37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_bulge37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(bulge37), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_bulgedH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable bulgedH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_bulgedH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(bulgedH), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_internal_loop37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable internal_loop37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_internal_loop37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(internal_loop37), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_internal_loopdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable internal_loopdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_internal_loopdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(internal_loopdH), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchI37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchI37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchI37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchI37), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchIdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchIdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchIdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchIdH), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatch1nI37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatch1nI37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatch1nI37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatch1nI37), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatch23I37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatch23I37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatch23I37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatch23I37), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatch1nIdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatch1nIdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatch1nIdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatch1nIdH), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatch23IdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatch23IdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatch23IdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatch23IdH), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchH37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchH37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchH37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchH37), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchM37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchM37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchM37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchM37), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchHdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchHdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchHdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchHdH), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchMdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchMdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchMdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchMdH), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchExt37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchExt37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchExt37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchExt37), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_mismatchExtdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable mismatchExtdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_mismatchExtdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(mismatchExtdH), SWIGTYPE_p_a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_dangle5_37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable dangle5_37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_dangle5_37_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t i, j;
    //dangle5_37, 7+1, 5
    pyobj = PyList_New(7+1);
    for (i = 0; i < 7+1; i++) {
      PyObject *l = PyList_New(5);
      for (j = 0; j < 5; j++) {
        PyObject *o = PyLong_FromLong((long) dangle5_37[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(pyobj,i,l);
    }
  }
  return pyobj;
}


SWIGINTERN int Swig_var_dangle3_37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable dangle3_37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_dangle3_37_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t i, j;
    //dangle3_37, 7+1, 5
    pyobj = PyList_New(7+1);
    for (i = 0; i < 7+1; i++) {
      PyObject *l = PyList_New(5);
      for (j = 0; j < 5; j++) {
        PyObject *o = PyLong_FromLong((long) dangle3_37[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(pyobj,i,l);
    }
  }
  return pyobj;
}


SWIGINTERN int Swig_var_dangle3_dH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable dangle3_dH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_dangle3_dH_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t i, j;
    //dangle3_dH, 7+1, 5
    pyobj = PyList_New(7+1);
    for (i = 0; i < 7+1; i++) {
      PyObject *l = PyList_New(5);
      for (j = 0; j < 5; j++) {
        PyObject *o = PyLong_FromLong((long) dangle3_dH[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(pyobj,i,l);
    }
  }
  return pyobj;
}


SWIGINTERN int Swig_var_dangle5_dH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable dangle5_dH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_dangle5_dH_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t i, j;
    //dangle5_dH, 7+1, 5
    pyobj = PyList_New(7+1);
    for (i = 0; i < 7+1; i++) {
      PyObject *l = PyList_New(5);
      for (j = 0; j < 5; j++) {
        PyObject *o = PyLong_FromLong((long) dangle5_dH[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(pyobj,i,l);
    }
  }
  return pyobj;
}


SWIGINTERN int Swig_var_int11_37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable int11_37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_int11_37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(int11_37), SWIGTYPE_p_a_7_1__a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_int11_dH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable int11_dH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_int11_dH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(int11_dH), SWIGTYPE_p_a_7_1__a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_int21_37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable int21_37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_int21_37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(int21_37), SWIGTYPE_p_a_7_1__a_5__a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_int21_dH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable int21_dH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_int21_dH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(int21_dH), SWIGTYPE_p_a_7_1__a_5__a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_int22_37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable int22_37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_int22_37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(int22_37), SWIGTYPE_p_a_7_1__a_5__a_5__a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_int22_dH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable int22_dH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_int22_dH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(int22_dH), SWIGTYPE_p_a_7_1__a_5__a_5__a_5__a_5__int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_ML_BASE37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ML_BASE37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ML_BASE37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(ML_BASE37));
  return pyobj;
}


SWIGINTERN int Swig_var_ML_BASEdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ML_BASEdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ML_BASEdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(ML_BASEdH));
  return pyobj;
}


SWIGINTERN int Swig_var_ML_closing37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ML_closing37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ML_closing37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(ML_closing37));
  return pyobj;
}


SWIGINTERN int Swig_var_ML_closingdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ML_closingdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ML_closingdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(ML_closingdH));
  return pyobj;
}


SWIGINTERN int Swig_var_ML_intern37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ML_intern37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ML_intern37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(ML_intern37));
  return pyobj;
}


SWIGINTERN int Swig_var_ML_interndH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ML_interndH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ML_interndH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(ML_interndH));
  return pyobj;
}


SWIGINTERN int Swig_var_TripleC37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TripleC37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TripleC37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(TripleC37));
  return pyobj;
}


SWIGINTERN int Swig_var_TripleCdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TripleCdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TripleCdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(TripleCdH));
  return pyobj;
}


SWIGINTERN int Swig_var_MultipleCA37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultipleCA37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultipleCA37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(MultipleCA37));
  return pyobj;
}


SWIGINTERN int Swig_var_MultipleCAdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultipleCAdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultipleCAdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(MultipleCAdH));
  return pyobj;
}


SWIGINTERN int Swig_var_MultipleCB37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultipleCB37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultipleCB37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(MultipleCB37));
  return pyobj;
}


SWIGINTERN int Swig_var_MultipleCBdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MultipleCBdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MultipleCBdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(MultipleCBdH));
  return pyobj;
}


SWIGINTERN int Swig_var_MAX_NINIO_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable MAX_NINIO is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_MAX_NINIO_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(MAX_NINIO));
  return pyobj;
}


SWIGINTERN int Swig_var_ninio37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable ninio37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_ninio37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(ninio37));
  return pyobj;
}


SWIGINTERN int Swig_var_niniodH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable niniodH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_niniodH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(niniodH));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminalAU37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminalAU37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminalAU37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(TerminalAU37));
  return pyobj;
}


SWIGINTERN int Swig_var_TerminalAUdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TerminalAUdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TerminalAUdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(TerminalAUdH));
  return pyobj;
}


SWIGINTERN int Swig_var_DuplexInit37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DuplexInit37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DuplexInit37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(DuplexInit37));
  return pyobj;
}


SWIGINTERN int Swig_var_DuplexInitdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable DuplexInitdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_DuplexInitdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(DuplexInitdH));
  return pyobj;
}


SWIGINTERN int Swig_var_Tetraloops_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Tetraloops is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Tetraloops_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t size = SWIG_strnlen(Tetraloops, 281);
    
    
    
    pyobj = SWIG_FromCharPtrAndSize(Tetraloops, size);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_Tetraloop37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Tetraloop37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Tetraloop37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(Tetraloop37), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_TetraloopdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TetraloopdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TetraloopdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(TetraloopdH), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_Triloops_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triloops is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triloops_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t size = SWIG_strnlen(Triloops, 241);
    
    
    
    pyobj = SWIG_FromCharPtrAndSize(Triloops, size);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_Triloop37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Triloop37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Triloop37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(Triloop37), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_TriloopdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable TriloopdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_TriloopdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(TriloopdH), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_Hexaloops_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Hexaloops is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Hexaloops_get(void) {
  PyObject *pyobj = 0;
  
  {
    size_t size = SWIG_strnlen(Hexaloops, 361);
    
    
    
    pyobj = SWIG_FromCharPtrAndSize(Hexaloops, size);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_Hexaloop37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Hexaloop37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Hexaloop37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(Hexaloop37), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_HexaloopdH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable HexaloopdH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_HexaloopdH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(HexaloopdH), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_GQuadAlpha37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GQuadAlpha37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GQuadAlpha37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(GQuadAlpha37));
  return pyobj;
}


SWIGINTERN int Swig_var_GQuadAlphadH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GQuadAlphadH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GQuadAlphadH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(GQuadAlphadH));
  return pyobj;
}


SWIGINTERN int Swig_var_GQuadBeta37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GQuadBeta37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GQuadBeta37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(GQuadBeta37));
  return pyobj;
}


SWIGINTERN int Swig_var_GQuadBetadH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GQuadBetadH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GQuadBetadH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(GQuadBetadH));
  return pyobj;
}


SWIGINTERN int Swig_var_GQuadLayerMismatch37_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GQuadLayerMismatch37 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GQuadLayerMismatch37_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(GQuadLayerMismatch37));
  return pyobj;
}


SWIGINTERN int Swig_var_GQuadLayerMismatchH_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GQuadLayerMismatchH is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GQuadLayerMismatchH_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(GQuadLayerMismatchH));
  return pyobj;
}


SWIGINTERN int Swig_var_GQuadLayerMismatchMax_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable GQuadLayerMismatchMax is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_GQuadLayerMismatchMax_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(GQuadLayerMismatchMax));
  return pyobj;
}


SWIGINTERN int Swig_var_Tmeasure_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable Tmeasure is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_Tmeasure_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(Tmeasure));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_md_temperature_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_temperature_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_temperature_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_temperature_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->temperature = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_temperature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_temperature_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (double) ((arg1)->temperature);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_betaScale_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_betaScale_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_betaScale_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_betaScale_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->betaScale = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_betaScale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_betaScale_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (double) ((arg1)->betaScale);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_pf_smooth_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_pf_smooth_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_pf_smooth_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_pf_smooth_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->pf_smooth = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_pf_smooth_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_pf_smooth_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->pf_smooth);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_dangles_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_dangles_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_dangles_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_dangles_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->dangles = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_dangles_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_dangles_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->dangles);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_special_hp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_special_hp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_special_hp_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_special_hp_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->special_hp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_special_hp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_special_hp_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->special_hp);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_noLP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_noLP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_noLP_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_noLP_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->noLP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_noLP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_noLP_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->noLP);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_noGU_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_noGU_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_noGU_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_noGU_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->noGU = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_noGU_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_noGU_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->noGU);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_noGUclosure_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_noGUclosure_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_noGUclosure_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_noGUclosure_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->noGUclosure = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_noGUclosure_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_noGUclosure_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->noGUclosure);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_logML_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_logML_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_logML_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_logML_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->logML = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_logML_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_logML_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->logML);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_circ_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_circ_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_circ_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_circ_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->circ = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_circ_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_circ_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->circ);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_circ_penalty_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_circ_penalty_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_circ_penalty_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_circ_penalty_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->circ_penalty = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_circ_penalty_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_circ_penalty_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->circ_penalty);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_gquad_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_gquad_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_gquad_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_gquad_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->gquad = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_gquad_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_gquad_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->gquad);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_uniq_ML_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_uniq_ML_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_uniq_ML_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_uniq_ML_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->uniq_ML = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_uniq_ML_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_uniq_ML_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->uniq_ML);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_energy_set_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_energy_set_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_energy_set_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_energy_set_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->energy_set = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_energy_set_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_energy_set_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->energy_set);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_backtrack_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_backtrack_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_backtrack_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_backtrack_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->backtrack = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_backtrack_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_backtrack_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->backtrack);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_backtrack_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_backtrack_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_backtrack_type_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_backtrack_type_set" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  if (arg1) (arg1)->backtrack_type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_backtrack_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_backtrack_type_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (char) ((arg1)->backtrack_type);
  resultobj = SWIG_From_char(static_cast< char >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_compute_bpp_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_compute_bpp_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_compute_bpp_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_compute_bpp_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->compute_bpp = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_compute_bpp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_compute_bpp_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->compute_bpp);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_nonstandards_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  char *arg2 = (char *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char temp2[64] ;
  int res2 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_nonstandards_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_nonstandards_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  res2 = SWIG_AsCharArray(swig_obj[1], temp2, 64);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "md_nonstandards_set" "', argument " "2"" of type '" "char [64]""'");
  }
  arg2 = reinterpret_cast< char * >(temp2);
  if (arg2) memcpy(arg1->nonstandards,arg2,64*sizeof(char));
  else memset(arg1->nonstandards,0,64*sizeof(char));
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_nonstandards_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_nonstandards_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (char *)(char *) ((arg1)->nonstandards);
  {
    size_t size = SWIG_strnlen(result, 64);
    
    
    
    resultobj = SWIG_FromCharPtrAndSize(result, size);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_max_bp_span_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_max_bp_span_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_max_bp_span_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_max_bp_span_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->max_bp_span = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_max_bp_span_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_max_bp_span_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->max_bp_span);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_min_loop_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_min_loop_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_min_loop_size_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_min_loop_size_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->min_loop_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_min_loop_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_min_loop_size_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->min_loop_size);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_window_size_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_window_size_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_window_size_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_window_size_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->window_size = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_window_size_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_window_size_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->window_size);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_oldAliEn_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_oldAliEn_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_oldAliEn_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_oldAliEn_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->oldAliEn = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_oldAliEn_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_oldAliEn_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->oldAliEn);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_ribo_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_ribo_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_ribo_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_ribo_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->ribo = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_ribo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_ribo_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->ribo);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_cv_fact_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_cv_fact_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_cv_fact_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_cv_fact_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->cv_fact = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_cv_fact_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_cv_fact_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (double) ((arg1)->cv_fact);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_nc_fact_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_nc_fact_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_nc_fact_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_nc_fact_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->nc_fact = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_nc_fact_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_nc_fact_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (double) ((arg1)->nc_fact);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_sfact_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_sfact_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_sfact_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_sfact_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->sfact = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_sfact_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_sfact_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (double) ((arg1)->sfact);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_rtype_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_rtype_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int *)(int *) ((arg1)->rtype);
  {
    int i;
    resultobj = PyList_New(8);
    for (i = 0; i < 8; i++) {
      PyObject *o = PyLong_FromLong((long) result[i]);
      PyList_SetItem(resultobj,i,o);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_alias_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_alias_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (short *)(short *) ((arg1)->alias);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_pair_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int (*result)[MAXALPHA+1] = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_pair_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int (*)[MAXALPHA+1])(int (*)[MAXALPHA+1]) ((arg1)->pair);
  {
    size_t i, j;
    //result, MAXALPHA+1, MAXALPHA+1
    resultobj = PyList_New(MAXALPHA+1);
    for (i = 0; i < MAXALPHA+1; i++) {
      PyObject *l = PyList_New(MAXALPHA+1);
      for (j = 0; j < MAXALPHA+1; j++) {
        PyObject *o = PyLong_FromLong((long) result[i][j]);
        PyList_SetItem(l, j, o);
      }
      PyList_SetItem(resultobj,i,l);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_salt_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_salt_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_salt_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_salt_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->salt = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_salt_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_salt_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (double) ((arg1)->salt);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltMLLower_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_saltMLLower_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltMLLower_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_saltMLLower_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->saltMLLower = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltMLLower_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltMLLower_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->saltMLLower);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltMLUpper_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_saltMLUpper_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltMLUpper_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_saltMLUpper_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->saltMLUpper = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltMLUpper_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltMLUpper_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->saltMLUpper);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltDPXInit_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_saltDPXInit_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltDPXInit_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_saltDPXInit_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->saltDPXInit = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltDPXInit_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltDPXInit_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (int) ((arg1)->saltDPXInit);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltDPXInitFact_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_saltDPXInitFact_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltDPXInitFact_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_saltDPXInitFact_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->saltDPXInitFact = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_saltDPXInitFact_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_saltDPXInitFact_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (float) ((arg1)->saltDPXInitFact);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_helical_rise_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_helical_rise_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_helical_rise_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_helical_rise_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->helical_rise = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_helical_rise_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_helical_rise_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (float) ((arg1)->helical_rise);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_backbone_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_backbone_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_backbone_length_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_backbone_length_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->backbone_length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_backbone_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_backbone_length_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (float) ((arg1)->backbone_length);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_circ_alpha0_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "md_circ_alpha0_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_circ_alpha0_set" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "md_circ_alpha0_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->circ_alpha0 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_circ_alpha0_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_circ_alpha0_get" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  result = (double) ((arg1)->circ_alpha0);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_md(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double arg1 = vrna_md_defaults_temperature_get() ;
  double arg2 = vrna_md_defaults_betaScale_get() ;
  int arg3 = vrna_md_defaults_pf_smooth_get() ;
  int arg4 = vrna_md_defaults_dangles_get() ;
  int arg5 = vrna_md_defaults_special_hp_get() ;
  int arg6 = vrna_md_defaults_noLP_get() ;
  int arg7 = vrna_md_defaults_noGU_get() ;
  int arg8 = vrna_md_defaults_noGUclosure_get() ;
  int arg9 = vrna_md_defaults_logML_get() ;
  int arg10 = vrna_md_defaults_circ_get() ;
  int arg11 = vrna_md_defaults_circ_penalty_get() ;
  int arg12 = vrna_md_defaults_gquad_get() ;
  int arg13 = vrna_md_defaults_uniq_ML_get() ;
  int arg14 = vrna_md_defaults_energy_set_get() ;
  int arg15 = vrna_md_defaults_backtrack_get() ;
  char arg16 = vrna_md_defaults_backtrack_type_get() ;
  int arg17 = vrna_md_defaults_compute_bpp_get() ;
  int arg18 = vrna_md_defaults_max_bp_span_get() ;
  int arg19 = vrna_md_defaults_min_loop_size_get() ;
  int arg20 = vrna_md_defaults_window_size_get() ;
  int arg21 = vrna_md_defaults_oldAliEn_get() ;
  int arg22 = vrna_md_defaults_ribo_get() ;
  double arg23 = vrna_md_defaults_cv_fact_get() ;
  double arg24 = vrna_md_defaults_nc_fact_get() ;
  double arg25 = vrna_md_defaults_sfact_get() ;
  double arg26 = vrna_md_defaults_salt_get() ;
  int arg27 = vrna_md_defaults_saltMLLower_get() ;
  int arg28 = vrna_md_defaults_saltMLUpper_get() ;
  int arg29 = vrna_md_defaults_saltDPXInit_get() ;
  float arg30 = vrna_md_defaults_saltDPXInitFact_get() ;
  float arg31 = vrna_md_defaults_helical_rise_get() ;
  float arg32 = vrna_md_defaults_backbone_length_get() ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  char val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  int val18 ;
  int ecode18 = 0 ;
  int val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  int val21 ;
  int ecode21 = 0 ;
  int val22 ;
  int ecode22 = 0 ;
  double val23 ;
  int ecode23 = 0 ;
  double val24 ;
  int ecode24 = 0 ;
  double val25 ;
  int ecode25 = 0 ;
  double val26 ;
  int ecode26 = 0 ;
  int val27 ;
  int ecode27 = 0 ;
  int val28 ;
  int ecode28 = 0 ;
  int val29 ;
  int ecode29 = 0 ;
  float val30 ;
  int ecode30 = 0 ;
  float val31 ;
  int ecode31 = 0 ;
  float val32 ;
  int ecode32 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  PyObject * obj20 = 0 ;
  PyObject * obj21 = 0 ;
  PyObject * obj22 = 0 ;
  PyObject * obj23 = 0 ;
  PyObject * obj24 = 0 ;
  PyObject * obj25 = 0 ;
  PyObject * obj26 = 0 ;
  PyObject * obj27 = 0 ;
  PyObject * obj28 = 0 ;
  PyObject * obj29 = 0 ;
  PyObject * obj30 = 0 ;
  PyObject * obj31 = 0 ;
  char * kwnames[] = {
    (char *)"temperature",  (char *)"betaScale",  (char *)"pf_smooth",  (char *)"dangles",  (char *)"special_hp",  (char *)"noLP",  (char *)"noGU",  (char *)"noGUclosure",  (char *)"logML",  (char *)"circ",  (char *)"circ_penalty",  (char *)"gquad",  (char *)"uniq_ML",  (char *)"energy_set",  (char *)"backtrack",  (char *)"backtrack_type",  (char *)"compute_bpp",  (char *)"max_bp_span",  (char *)"min_loop_size",  (char *)"window_size",  (char *)"oldAliEn",  (char *)"ribo",  (char *)"cv_fact",  (char *)"nc_fact",  (char *)"sfact",  (char *)"salt",  (char *)"saltMLLower",  (char *)"saltMLUpper",  (char *)"saltDPXInit",  (char *)"saltDPXInitFact",  (char *)"helical_rise",  (char *)"backbone_length",  NULL 
  };
  vrna_md_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO:new_md", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17, &obj18, &obj19, &obj20, &obj21, &obj22, &obj23, &obj24, &obj25, &obj26, &obj27, &obj28, &obj29, &obj30, &obj31)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_double(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_md" "', argument " "1"" of type '" "double""'");
    } 
    arg1 = static_cast< double >(val1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_double(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_md" "', argument " "2"" of type '" "double""'");
    } 
    arg2 = static_cast< double >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_md" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_md" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_md" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_md" "', argument " "6"" of type '" "int""'");
    } 
    arg6 = static_cast< int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "new_md" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "new_md" "', argument " "8"" of type '" "int""'");
    } 
    arg8 = static_cast< int >(val8);
  }
  if (obj8) {
    ecode9 = SWIG_AsVal_int(obj8, &val9);
    if (!SWIG_IsOK(ecode9)) {
      SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "new_md" "', argument " "9"" of type '" "int""'");
    } 
    arg9 = static_cast< int >(val9);
  }
  if (obj9) {
    ecode10 = SWIG_AsVal_int(obj9, &val10);
    if (!SWIG_IsOK(ecode10)) {
      SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "new_md" "', argument " "10"" of type '" "int""'");
    } 
    arg10 = static_cast< int >(val10);
  }
  if (obj10) {
    ecode11 = SWIG_AsVal_int(obj10, &val11);
    if (!SWIG_IsOK(ecode11)) {
      SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "new_md" "', argument " "11"" of type '" "int""'");
    } 
    arg11 = static_cast< int >(val11);
  }
  if (obj11) {
    ecode12 = SWIG_AsVal_int(obj11, &val12);
    if (!SWIG_IsOK(ecode12)) {
      SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "new_md" "', argument " "12"" of type '" "int""'");
    } 
    arg12 = static_cast< int >(val12);
  }
  if (obj12) {
    ecode13 = SWIG_AsVal_int(obj12, &val13);
    if (!SWIG_IsOK(ecode13)) {
      SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "new_md" "', argument " "13"" of type '" "int""'");
    } 
    arg13 = static_cast< int >(val13);
  }
  if (obj13) {
    ecode14 = SWIG_AsVal_int(obj13, &val14);
    if (!SWIG_IsOK(ecode14)) {
      SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "new_md" "', argument " "14"" of type '" "int""'");
    } 
    arg14 = static_cast< int >(val14);
  }
  if (obj14) {
    ecode15 = SWIG_AsVal_int(obj14, &val15);
    if (!SWIG_IsOK(ecode15)) {
      SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "new_md" "', argument " "15"" of type '" "int""'");
    } 
    arg15 = static_cast< int >(val15);
  }
  if (obj15) {
    ecode16 = SWIG_AsVal_char(obj15, &val16);
    if (!SWIG_IsOK(ecode16)) {
      SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "new_md" "', argument " "16"" of type '" "char""'");
    } 
    arg16 = static_cast< char >(val16);
  }
  if (obj16) {
    ecode17 = SWIG_AsVal_int(obj16, &val17);
    if (!SWIG_IsOK(ecode17)) {
      SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "new_md" "', argument " "17"" of type '" "int""'");
    } 
    arg17 = static_cast< int >(val17);
  }
  if (obj17) {
    ecode18 = SWIG_AsVal_int(obj17, &val18);
    if (!SWIG_IsOK(ecode18)) {
      SWIG_exception_fail(SWIG_ArgError(ecode18), "in method '" "new_md" "', argument " "18"" of type '" "int""'");
    } 
    arg18 = static_cast< int >(val18);
  }
  if (obj18) {
    ecode19 = SWIG_AsVal_int(obj18, &val19);
    if (!SWIG_IsOK(ecode19)) {
      SWIG_exception_fail(SWIG_ArgError(ecode19), "in method '" "new_md" "', argument " "19"" of type '" "int""'");
    } 
    arg19 = static_cast< int >(val19);
  }
  if (obj19) {
    ecode20 = SWIG_AsVal_int(obj19, &val20);
    if (!SWIG_IsOK(ecode20)) {
      SWIG_exception_fail(SWIG_ArgError(ecode20), "in method '" "new_md" "', argument " "20"" of type '" "int""'");
    } 
    arg20 = static_cast< int >(val20);
  }
  if (obj20) {
    ecode21 = SWIG_AsVal_int(obj20, &val21);
    if (!SWIG_IsOK(ecode21)) {
      SWIG_exception_fail(SWIG_ArgError(ecode21), "in method '" "new_md" "', argument " "21"" of type '" "int""'");
    } 
    arg21 = static_cast< int >(val21);
  }
  if (obj21) {
    ecode22 = SWIG_AsVal_int(obj21, &val22);
    if (!SWIG_IsOK(ecode22)) {
      SWIG_exception_fail(SWIG_ArgError(ecode22), "in method '" "new_md" "', argument " "22"" of type '" "int""'");
    } 
    arg22 = static_cast< int >(val22);
  }
  if (obj22) {
    ecode23 = SWIG_AsVal_double(obj22, &val23);
    if (!SWIG_IsOK(ecode23)) {
      SWIG_exception_fail(SWIG_ArgError(ecode23), "in method '" "new_md" "', argument " "23"" of type '" "double""'");
    } 
    arg23 = static_cast< double >(val23);
  }
  if (obj23) {
    ecode24 = SWIG_AsVal_double(obj23, &val24);
    if (!SWIG_IsOK(ecode24)) {
      SWIG_exception_fail(SWIG_ArgError(ecode24), "in method '" "new_md" "', argument " "24"" of type '" "double""'");
    } 
    arg24 = static_cast< double >(val24);
  }
  if (obj24) {
    ecode25 = SWIG_AsVal_double(obj24, &val25);
    if (!SWIG_IsOK(ecode25)) {
      SWIG_exception_fail(SWIG_ArgError(ecode25), "in method '" "new_md" "', argument " "25"" of type '" "double""'");
    } 
    arg25 = static_cast< double >(val25);
  }
  if (obj25) {
    ecode26 = SWIG_AsVal_double(obj25, &val26);
    if (!SWIG_IsOK(ecode26)) {
      SWIG_exception_fail(SWIG_ArgError(ecode26), "in method '" "new_md" "', argument " "26"" of type '" "double""'");
    } 
    arg26 = static_cast< double >(val26);
  }
  if (obj26) {
    ecode27 = SWIG_AsVal_int(obj26, &val27);
    if (!SWIG_IsOK(ecode27)) {
      SWIG_exception_fail(SWIG_ArgError(ecode27), "in method '" "new_md" "', argument " "27"" of type '" "int""'");
    } 
    arg27 = static_cast< int >(val27);
  }
  if (obj27) {
    ecode28 = SWIG_AsVal_int(obj27, &val28);
    if (!SWIG_IsOK(ecode28)) {
      SWIG_exception_fail(SWIG_ArgError(ecode28), "in method '" "new_md" "', argument " "28"" of type '" "int""'");
    } 
    arg28 = static_cast< int >(val28);
  }
  if (obj28) {
    ecode29 = SWIG_AsVal_int(obj28, &val29);
    if (!SWIG_IsOK(ecode29)) {
      SWIG_exception_fail(SWIG_ArgError(ecode29), "in method '" "new_md" "', argument " "29"" of type '" "int""'");
    } 
    arg29 = static_cast< int >(val29);
  }
  if (obj29) {
    ecode30 = SWIG_AsVal_float(obj29, &val30);
    if (!SWIG_IsOK(ecode30)) {
      SWIG_exception_fail(SWIG_ArgError(ecode30), "in method '" "new_md" "', argument " "30"" of type '" "float""'");
    } 
    arg30 = static_cast< float >(val30);
  }
  if (obj30) {
    ecode31 = SWIG_AsVal_float(obj30, &val31);
    if (!SWIG_IsOK(ecode31)) {
      SWIG_exception_fail(SWIG_ArgError(ecode31), "in method '" "new_md" "', argument " "31"" of type '" "float""'");
    } 
    arg31 = static_cast< float >(val31);
  }
  if (obj31) {
    ecode32 = SWIG_AsVal_float(obj31, &val32);
    if (!SWIG_IsOK(ecode32)) {
      SWIG_exception_fail(SWIG_ArgError(ecode32), "in method '" "new_md" "', argument " "32"" of type '" "float""'");
    } 
    arg32 = static_cast< float >(val32);
  }
  {
    try {
      result = (vrna_md_t *)new_vrna_md_t(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27,arg28,arg29,arg30,arg31,arg32);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_md_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_md(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_md" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  {
    try {
      delete_vrna_md_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_reset" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  {
    try {
      vrna_md_t_reset(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_set_from_globals(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_set_from_globals" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  {
    try {
      vrna_md_t_set_from_globals(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md_option_string(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md_option_string" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  {
    try {
      result = (char *)vrna_md_t_option_string(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_md___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_md_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "md___str__" "', argument " "1"" of type '" "vrna_md_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_md_t * >(argp1);
  {
    try {
      result = vrna_md_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *md_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_md_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *md_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_temperature_set(PyObject *_val) {
  {
    vrna_md_defaults_temperature(PyFloat_AsDouble(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_temperature_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyFloat_FromDouble(vrna_md_defaults_temperature_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_dangles_set(PyObject *_val) {
  {
    vrna_md_defaults_dangles((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_dangles_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_dangles_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_betaScale_set(PyObject *_val) {
  {
    vrna_md_defaults_betaScale(PyFloat_AsDouble(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_betaScale_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyFloat_FromDouble(vrna_md_defaults_betaScale_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_pf_smooth_set(PyObject *_val) {
  {
    vrna_md_defaults_pf_smooth((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_pf_smooth_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_pf_smooth_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_tetra_loop_set(PyObject *_val) {
  {
    vrna_md_defaults_special_hp((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_tetra_loop_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_special_hp_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_special_hp_set(PyObject *_val) {
  {
    vrna_md_defaults_special_hp((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_special_hp_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_special_hp_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_noLonelyPairs_set(PyObject *_val) {
  {
    vrna_md_defaults_noLP((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_noLonelyPairs_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_noLP_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_noLP_set(PyObject *_val) {
  {
    vrna_md_defaults_noLP((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_noLP_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_noLP_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_noGU_set(PyObject *_val) {
  {
    vrna_md_defaults_noGU((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_noGU_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_noGU_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_no_closingGU_set(PyObject *_val) {
  {
    vrna_md_defaults_noGUclosure((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_no_closingGU_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_noGUclosure_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_noGUclosure_set(PyObject *_val) {
  {
    vrna_md_defaults_noGUclosure((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_noGUclosure_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_noGUclosure_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_logML_set(PyObject *_val) {
  {
    vrna_md_defaults_logML((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_logML_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_logML_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_circ_set(PyObject *_val) {
  {
    vrna_md_defaults_circ((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_circ_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_circ_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_circ_penalty_set(PyObject *_val) {
  {
    vrna_md_defaults_circ_penalty((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_circ_penalty_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_circ_penalty_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_gquad_set(PyObject *_val) {
  {
    vrna_md_defaults_gquad((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_gquad_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_gquad_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_uniq_ML_set(PyObject *_val) {
  {
    vrna_md_defaults_uniq_ML((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_uniq_ML_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_uniq_ML_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_energy_set_set(PyObject *_val) {
  {
    vrna_md_defaults_energy_set((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_energy_set_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_energy_set_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_backtrack_set(PyObject *_val) {
  {
    vrna_md_defaults_backtrack((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_backtrack_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_backtrack_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_backtrack_type_set(PyObject *_val) {
  {
    char val;
    int res = SWIG_AsVal_char(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""backtrack_type""' of type '""char""'");
    }
    backtrack_type = static_cast< char >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_backtrack_type_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_char(static_cast< char >(backtrack_type));
  return pyobj;
}


SWIGINTERN int Swig_var_do_backtrack_set(PyObject *_val) {
  {
    vrna_md_defaults_compute_bpp((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_do_backtrack_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_compute_bpp_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_compute_bpp_set(PyObject *_val) {
  {
    vrna_md_defaults_compute_bpp((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_compute_bpp_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_compute_bpp_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_max_bp_span_set(PyObject *_val) {
  {
    vrna_md_defaults_max_bp_span((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_max_bp_span_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_max_bp_span_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_min_loop_size_set(PyObject *_val) {
  {
    vrna_md_defaults_min_loop_size((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_min_loop_size_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_min_loop_size_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_window_size_set(PyObject *_val) {
  {
    vrna_md_defaults_window_size((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_window_size_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_window_size_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_oldAliEn_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""oldAliEn""' of type '""int""'");
    }
    oldAliEn = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_oldAliEn_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(oldAliEn));
  return pyobj;
}


SWIGINTERN int Swig_var_ribo_set(PyObject *_val) {
  {
    vrna_md_defaults_ribo((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_ribo_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_ribo_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_cv_fact_set(PyObject *_val) {
  {
    vrna_md_defaults_cv_fact(PyFloat_AsDouble(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_cv_fact_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyFloat_FromDouble(vrna_md_defaults_cv_fact_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_nc_fact_set(PyObject *_val) {
  {
    vrna_md_defaults_nc_fact(PyFloat_AsDouble(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_nc_fact_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyFloat_FromDouble(vrna_md_defaults_nc_fact_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_sfact_set(PyObject *_val) {
  {
    vrna_md_defaults_sfact(PyFloat_AsDouble(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_sfact_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyFloat_FromDouble(vrna_md_defaults_sfact_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_salt_set(PyObject *_val) {
  {
    vrna_md_defaults_salt(PyFloat_AsDouble(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_salt_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyFloat_FromDouble((double)vrna_md_defaults_salt_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_saltDPXInit_set(PyObject *_val) {
  {
    vrna_md_defaults_saltDPXInit((int)PyLong_AsLong(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_saltDPXInit_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyLong_FromLong((long)vrna_md_defaults_saltDPXInit_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_saltDPXInitFact_set(PyObject *_val) {
  {
    vrna_md_defaults_saltDPXInitFact((float)PyFloat_AsDouble(_val));
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_saltDPXInitFact_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = PyFloat_FromDouble((double)vrna_md_defaults_saltDPXInitFact_get());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_pf_scale_set(PyObject *_val) {
  {
    double val;
    int res = SWIG_AsVal_double(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""pf_scale""' of type '""double""'");
    }
    pf_scale = static_cast< double >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_pf_scale_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(pf_scale));
  return pyobj;
}


SWIGINTERN int Swig_var_nonstandards_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""nonstandards""' of type '""char *""'");
    }
    delete[] nonstandards;
    if (alloc == SWIG_NEWOBJ) {
      nonstandards = cptr;
    } else {
      nonstandards = csize ? (char *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_nonstandards_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(nonstandards);
  return pyobj;
}


SWIGINTERN PyObject *_wrap_init_rand__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      vrna_init_rand();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_init_rand__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "init_rand" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      vrna_init_rand_seed(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_init_rand(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "init_rand", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_init_rand__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_init_rand__SWIG_1(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'init_rand'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_init_rand(void)\n"
    "    vrna_init_rand_seed(unsigned int)\n");
  return 0;
}


SWIGINTERN int Swig_var_xsubi_set(PyObject *_val) {
  {
    unsigned short *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_unsigned_short,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""xsubi""' of type '""unsigned short [3]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)3; ++ii) *(unsigned short *)&xsubi[ii] = *((unsigned short *)inp + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""xsubi""' of type '""unsigned short [3]""'");
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_xsubi_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(xsubi), SWIGTYPE_p_unsigned_short,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_urn(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  double result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "urn", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (double)vrna_urn();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_int_urn(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"_from",  (char *)"to",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:int_urn", kwnames, &obj0, &obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "int_urn" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "int_urn" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (int)vrna_int_urn(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hamming(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"s1",  (char *)"s2",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:hamming", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hamming" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hamming" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)my_hamming((char const *)arg1,(char const *)arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_hamming_bound(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"s1",  (char *)"s2",  (char *)"n",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:hamming_bound", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hamming_bound" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hamming_bound" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "hamming_bound" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)my_hamming_bound((char const *)arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_encode_seq(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  NULL 
  };
  short *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:encode_seq", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "encode_seq" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (short *)encode_seq(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_strtrim(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = (char *)NULL ;
  unsigned int arg3 = 0 ;
  unsigned int arg4 = VRNA_TRIM_DEFAULT ;
  int res1 ;
  char *t1 = 0 ;
  size_t n1 = 0 ;
  int alloc1 = 0 ;
  size_t expansion1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"seq_mutable",  (char *)"delimiters",  (char *)"keep",  (char *)"options",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:strtrim", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &t1, &n1, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "strtrim" "', argument " "1"" of type '" "char *seq_mutable""'");
  }
  arg1 = (new char[n1+expansion1]());          
  memcpy(arg1,t1,sizeof(char)*n1);
  if (alloc1 == SWIG_NEWOBJ) delete[] t1;
  arg1[n1-1] = 0;
  if (obj1) {
    res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "strtrim" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "strtrim" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "strtrim" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (unsigned int)my_strtrim(arg1,(char const *)arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_FromCharPtr(arg1), 0);
  delete[] arg1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_str_to_dbl_array(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string const &arg2_defvalue = " " ;
  std::string *arg2 = (std::string *) &arg2_defvalue ;
  unsigned int arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"s",  (char *)"delimiter",  (char *)"options",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:str_to_dbl_array", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    res1 = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "str_to_dbl_array" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "str_to_dbl_array" "', argument " "1"" of type '" "std::string const &""'"); 
    }
    arg1 = ptr;
  }
  if (obj1) {
    {
      std::string *ptr = (std::string *)0;
      res2 = SWIG_AsPtr_std_string(obj1, &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "str_to_dbl_array" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "str_to_dbl_array" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      arg2 = ptr;
    }
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "str_to_dbl_array" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = my_str_to_dbl_array((std::string const &)*arg1,(std::string const &)*arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_random_string(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  char *arg2 = (char *)0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"l",  (char *)"symbols",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:random_string", kwnames, &obj0, &obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "random_string" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "random_string" "', argument " "2"" of type '" "char const []""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)vrna_random_string(arg1,(char const (*))arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_hamming_distance(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"s1",  (char *)"s2",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:hamming_distance", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hamming_distance" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hamming_distance" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)vrna_hamming_distance((char const *)arg1,(char const *)arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_hamming_distance_bound(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"s1",  (char *)"s2",  (char *)"n",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:hamming_distance_bound", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hamming_distance_bound" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hamming_distance_bound" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "hamming_distance_bound" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_hamming_distance_bound((char const *)arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_i_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ep_i_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_i_set" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ep_i_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->i = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_i_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_i_get" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  result = (int) ((arg1)->i);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_j_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ep_j_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_j_set" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ep_j_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->j = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_j_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_j_get" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  result = (int) ((arg1)->j);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_p_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ep_p_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_p_set" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ep_p_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->p = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_p_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_p_get" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  result = (float) ((arg1)->p);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "ep_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_type_set" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ep_type_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep_type_get" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  result = (int) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_ep(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  float arg3 = 1. ;
  int arg4 = VRNA_PLIST_TYPE_BASEPAIR ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  (char *)"p",  (char *)"type",  NULL 
  };
  vrna_ep_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:new_ep", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ep" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ep" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_float(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ep" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = static_cast< float >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ep" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  {
    try {
      result = (vrna_ep_t *)new_vrna_ep_t(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ep___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ep___str__" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  {
    try {
      result = vrna_ep_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_ep(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_ep_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_ep_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ep" "', argument " "1"" of type '" "vrna_ep_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_ep_t * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *ep_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_ep_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *ep_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_pack_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"s",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:pack_structure", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pack_structure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_pack_structure((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_unpack_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"packed",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:unpack_structure", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unpack_structure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_unpack_structure((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_from_ptable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "db_from_ptable" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (char *)my_db_from_ptable(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_from_ptable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "db_from_ptable" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "db_from_ptable" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    if ((!((*arg1).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg1).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg1).data[0]) != (*arg1).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (char *)my_db_from_ptable((var_array< short > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_from_ptable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "db_from_ptable", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_db_from_ptable__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_db_from_ptable__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'db_from_ptable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_db_from_ptable(std::vector< int,std::allocator< int > >)\n"
    "    my_db_from_ptable(var_array< short > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_db_flatten__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  unsigned int arg2 = VRNA_BRACKETS_DEFAULT ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "db_flatten" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "db_flatten" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      db_flatten(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_flatten__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  std::string arg2 ;
  unsigned int arg3 = VRNA_BRACKETS_DEFAULT ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "db_flatten" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "db_flatten" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "db_flatten" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      db_flatten(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_flatten(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "db_flatten", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_db_flatten__SWIG_0(self, argc, argv);
      }
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_db_flatten__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_db_flatten__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_db_flatten__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'db_flatten'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    db_flatten(char *,unsigned int)\n"
    "    db_flatten(char *,std::string,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_db_from_WUSS(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"wuss",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:db_from_WUSS", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "db_from_WUSS" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = db_from_WUSS(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abstract_shapes__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 = 5 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "abstract_shapes" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "abstract_shapes" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = abstract_shapes(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abstract_shapes__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  unsigned int arg2 = 5 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "abstract_shapes" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "abstract_shapes" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = abstract_shapes(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abstract_shapes__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  unsigned int arg2 = 5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abstract_shapes" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "abstract_shapes" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "abstract_shapes" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    if ((!((*arg1).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg1).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg1).data[0]) != (*arg1).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = abstract_shapes((var_array< short > const &)*arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_abstract_shapes(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "abstract_shapes", 0, 2, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_abstract_shapes__SWIG_2(self, argc, argv);
      }
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_abstract_shapes__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_abstract_shapes__SWIG_0(self, argc, argv);
      }
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_abstract_shapes__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_abstract_shapes__SWIG_1(self, argc, argv);
      }
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_abstract_shapes__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'abstract_shapes'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    abstract_shapes(std::string,unsigned int)\n"
    "    abstract_shapes(std::vector< int,std::allocator< int > >,unsigned int)\n"
    "    abstract_shapes(var_array< short > const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_ptable(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 = VRNA_BRACKETS_RND ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"str",  (char *)"options",  NULL 
  };
  var_array< short > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:ptable", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ptable" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ptable" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (var_array< short > *)my_ptable(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ptable_pk(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"str",  NULL 
  };
  std::vector< int,std::allocator< int > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:ptable_pk", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "ptable_pk" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_ptable_pk(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pt_pk_remove__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  unsigned int arg2 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::vector< int,std::allocator< int > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "pt_pk_remove" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pt_pk_remove" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = my_pt_pk_remove(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pt_pk_remove__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  unsigned int arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  var_array< short > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pt_pk_remove" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "pt_pk_remove" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  if (swig_obj[1]) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pt_pk_remove" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    if ((!((*arg1).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg1).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg1).data[0]) != (*arg1).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (var_array< short > *)my_pt_pk_remove((var_array< short > const &)*arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pt_pk_remove(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "pt_pk_remove", 0, 2, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_pt_pk_remove__SWIG_1(self, argc, argv);
      }
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_pt_pk_remove__SWIG_1(self, argc, argv);
      }
    }
  }
  if ((argc >= 1) && (argc <= 2)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_pt_pk_remove__SWIG_0(self, argc, argv);
      }
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_pt_pk_remove__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'pt_pk_remove'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_pt_pk_remove(std::vector< int,std::allocator< int > >,unsigned int)\n"
    "    my_pt_pk_remove(var_array< short > const &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_plist(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  float arg2 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  (char *)"pr",  NULL 
  };
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:plist", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plist" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plist" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  {
    try {
      result = my_plist(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_from_plist(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > arg1 ;
  unsigned int arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"elem_probs",  (char *)"length",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:db_from_plist", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "db_from_plist" "', argument " "1"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "db_from_plist" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = db_from_plist(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_pk_remove(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 = VRNA_BRACKETS_ANY ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  (char *)"options",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:db_pk_remove", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "db_pk_remove" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "db_pk_remove" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = db_pk_remove(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_to_tree_string(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  (char *)"type",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:db_to_tree_string", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "db_to_tree_string" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "db_to_tree_string" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = db_to_tree_string(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tree_string_unweight(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:tree_string_unweight", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "tree_string_unweight" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = tree_string_unweight(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tree_string_to_db(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:tree_string_to_db", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "tree_string_to_db" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = tree_string_to_db(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_make_loop_index(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  short *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:make_loop_index", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_loop_index" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (short *)make_loop_index((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_loopidx_from_ptable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  std::vector< int,std::allocator< int > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "loopidx_from_ptable" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_loopidx_from_ptable(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_loopidx_from_ptable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loopidx_from_ptable" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "loopidx_from_ptable" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    if ((!((*arg1).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg1).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg1).data[0]) != (*arg1).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (var_array< int > *)my_loopidx_from_ptable((var_array< short > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_loopidx_from_ptable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "loopidx_from_ptable", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_loopidx_from_ptable__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_loopidx_from_ptable__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'loopidx_from_ptable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_loopidx_from_ptable(std::vector< int,std::allocator< int > >)\n"
    "    my_loopidx_from_ptable(var_array< short > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_hx_start_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "hx_start_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_start_set" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hx_start_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->start = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_start_get" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  result = (unsigned int) ((arg1)->start);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_end_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "hx_end_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_end_set" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hx_end_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->end = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_end_get" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  result = (unsigned int) ((arg1)->end);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_length_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "hx_length_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_length_set" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hx_length_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->length = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_length_get" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  result = (unsigned int) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_up5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "hx_up5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_up5_set" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hx_up5_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->up5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_up5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_up5_get" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  result = (unsigned int) ((arg1)->up5);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_up3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "hx_up3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_up3_set" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hx_up3_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->up3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_up3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_up3_get" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  result = (unsigned int) ((arg1)->up3);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_hx(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 = 0 ;
  unsigned int arg5 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"start",  (char *)"end",  (char *)"length",  (char *)"up5",  (char *)"up3",  NULL 
  };
  vrna_hx_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:new_hx", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_hx" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_hx" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_hx" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_hx" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_hx" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = (vrna_hx_t *)new_vrna_hx_t(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx___str__" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  {
    try {
      result = vrna_hx_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_hx(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hx_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hx_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_hx" "', argument " "1"" of type '" "vrna_hx_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hx_t * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *hx_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_hx_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *hx_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_hx_from_ptable__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "hx_from_ptable" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_hx_from_ptable(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_from_ptable__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hx_from_ptable" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "hx_from_ptable" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  {
    if ((!((*arg1).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg1).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg1).data[0]) != (*arg1).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = my_hx_from_ptable((var_array< short > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx_from_ptable(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "hx_from_ptable", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_hx_from_ptable__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_hx_from_ptable__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'hx_from_ptable'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_hx_from_ptable(std::vector< int,std::allocator< int > >)\n"
    "    my_hx_from_ptable(var_array< short > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_hx_merge(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > arg1 ;
  int arg2 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"list",  (char *)"maxdist",  NULL 
  };
  std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:hx_merge", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *ptr = (std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "hx_merge" "', argument " "1"" of type '" "std::vector< vrna_hx_t,std::allocator< vrna_hx_t > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hx_merge" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  {
    try {
      result = my_hx_merge(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bp_distance__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  unsigned int arg3 = VRNA_BRACKETS_RND ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bp_distance" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bp_distance" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "bp_distance" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)my_bp_distance(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bp_distance__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bp_distance" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "bp_distance" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)my_bp_distance(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bp_distance__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "bp_distance" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "bp_distance" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "bp_distance" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "bp_distance" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  {
    try {
      result = (int)my_bp_distance((var_array< short > const &)*arg1,(var_array< short > const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bp_distance(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "bp_distance", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_bp_distance__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_bp_distance__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_bp_distance__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_bp_distance__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'bp_distance'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_bp_distance(std::string,std::string,unsigned int)\n"
    "    my_bp_distance(std::vector< int,std::allocator< int > >,std::vector< int,std::allocator< int > >)\n"
    "    my_bp_distance(var_array< short > const &,var_array< short > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_dist_mountain(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  unsigned int arg3 = 1 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"str1",  (char *)"str2",  (char *)"p",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:dist_mountain", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "dist_mountain" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "dist_mountain" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dist_mountain" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (double)my_dist_mountain(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_TP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TP_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_TP_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->TP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TP_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->TP);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_TN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TN_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_TN_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->TN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TN_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->TN);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FP_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_FP_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FP_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_FP_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->FP = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FP_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FP_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->FP);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FN_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_FN_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FN_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_FN_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->FN = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FN_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FN_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->FN);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TPR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_TPR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TPR_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_TPR_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->TPR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TPR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TPR_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->TPR);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_PPV_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_PPV_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_PPV_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_PPV_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->PPV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_PPV_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_PPV_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->PPV);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FPR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_FPR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FPR_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_FPR_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->FPR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FPR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FPR_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->FPR);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FOR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_FOR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FOR_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_FOR_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->FOR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FOR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FOR_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->FOR);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TNR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_TNR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TNR_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_TNR_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->TNR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_TNR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_TNR_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->TNR);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FDR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_FDR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FDR_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_FDR_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->FDR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FDR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FDR_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->FDR);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FNR_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_FNR_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FNR_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_FNR_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->FNR = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_FNR_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_FNR_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->FNR);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_NPV_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_NPV_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_NPV_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_NPV_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->NPV = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_NPV_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_NPV_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->NPV);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_F1_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_F1_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_F1_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_F1_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->F1 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_F1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_F1_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->F1);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_MCC_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "score_MCC_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_MCC_set" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "score_MCC_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->MCC = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score_MCC_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score_MCC_get" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  result = (double) ((arg1)->MCC);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_score(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double arg1 = 0. ;
  double arg2 = 0. ;
  double arg3 = 0. ;
  double arg4 = 0. ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"TP",  (char *)"TN",  (char *)"FP",  (char *)"FN",  NULL 
  };
  vrna_score_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:new_score", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_double(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_score" "', argument " "1"" of type '" "double""'");
    } 
    arg1 = static_cast< double >(val1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_double(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_score" "', argument " "2"" of type '" "double""'");
    } 
    arg2 = static_cast< double >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_double(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_score" "', argument " "3"" of type '" "double""'");
    } 
    arg3 = static_cast< double >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_double(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_score" "', argument " "4"" of type '" "double""'");
    } 
    arg4 = static_cast< double >(val4);
  }
  {
    try {
      result = (vrna_score_t *)new_vrna_score_t(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_score_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_score___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "score___str__" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  {
    try {
      result = vrna_score_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_score(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_score_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_score_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_score" "', argument " "1"" of type '" "vrna_score_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_score_t * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *score_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_score_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *score_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_compare_structure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  int arg3 = 0 ;
  unsigned int arg4 = VRNA_BRACKETS_RND ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< vrna_score_t > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "compare_structure" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "compare_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compare_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "compare_structure" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = my_compare_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new vrna_score_t(result)), SWIGTYPE_p_vrna_score_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compare_structure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< int,std::allocator< int > > arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  int arg3 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< vrna_score_t > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "compare_structure" "', argument " "1"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "compare_structure" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compare_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  {
    try {
      result = my_compare_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new vrna_score_t(result)), SWIGTYPE_p_vrna_score_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compare_structure__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  var_array< short > *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  int arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< vrna_score_t > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "compare_structure" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "compare_structure" "', argument " "1"" of type '" "var_array< short > const &""'"); 
  }
  arg1 = reinterpret_cast< var_array< short > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "compare_structure" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "compare_structure" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "compare_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  {
    try {
      result = my_compare_structure((var_array< short > const &)*arg1,(var_array< short > const &)*arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new vrna_score_t(result)), SWIGTYPE_p_vrna_score_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_compare_structure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "compare_structure", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_compare_structure__SWIG_2(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_compare_structure__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_compare_structure__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_compare_structure__SWIG_0(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_compare_structure__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< int,std::allocator< int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_compare_structure__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_compare_structure__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'compare_structure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_compare_structure(std::string,std::string,int,unsigned int)\n"
    "    my_compare_structure(std::vector< int,std::allocator< int > >,std::vector< int,std::allocator< int > >,int)\n"
    "    my_compare_structure(var_array< short > const &,var_array< short > const &,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_gq_parse(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int *arg2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > *arg3 = 0 ;
  unsigned int temp2 ;
  int res2 = SWIG_TMPOBJ ;
  std::vector< unsigned int,std::allocator< unsigned int > > temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  unsigned int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:gq_parse", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "gq_parse" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (unsigned int)my_gq_parse(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_int((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_std__vectorT_unsigned_int_t, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_pack(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"struc",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:db_pack", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "db_pack" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)vrna_db_pack((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_unpack(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"packed",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:db_unpack", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "db_unpack" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)vrna_db_unpack((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_db_to_element_string(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:db_to_element_string", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "db_to_element_string" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)vrna_db_to_element_string((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_gquad(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int *arg2 = 0 ;
  int *arg3 = (int *)0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"struc",  (char *)"L",  (char *)"l",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:parse_gquad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_gquad" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_gquad" "', argument " "2"" of type '" "int *""'"); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "parse_gquad" "', argument " "3"" of type '" "int [3]""'"); 
  } 
  arg3 = reinterpret_cast< int * >(argp3);
  {
    try {
      result = (int)parse_gquad((char const *)arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_plist_gquad_from_db(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  float arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  (char *)"pr",  NULL 
  };
  plist *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:get_plist_gquad_from_db", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_plist_gquad_from_db" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_plist_gquad_from_db" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  {
    try {
      result = (plist *)get_plist_gquad_from_db((char const *)arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_elem_prob_s, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aln_consensus_sequence(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"md_p",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:aln_consensus_sequence", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aln_consensus_sequence" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aln_consensus_sequence" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = my_aln_consensus_sequence(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aln_consensus_mis(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"md_p",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:aln_consensus_mis", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aln_consensus_mis" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aln_consensus_mis" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = my_aln_consensus_mis(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_aln_consensus_sequence2(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"md_p",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:my_aln_consensus_sequence2", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "my_aln_consensus_sequence2" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "my_aln_consensus_sequence2" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = my_aln_consensus_sequence2(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_consens_mis(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"md_p",  NULL 
  };
  std::string result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:consens_mis", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "consens_mis" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "consens_mis" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = my_aln_consensus_mis2(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aln_mpi(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:aln_mpi", kwnames, &obj0)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aln_mpi" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)my_aln_mpi(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aln_pscore(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"md",  NULL 
  };
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:aln_pscore", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aln_pscore" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aln_pscore" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = my_aln_pscore(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aln_conservation_struct(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::string arg2 ;
  vrna_md_t *arg3 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"structure",  (char *)"md",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:aln_conservation_struct", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aln_conservation_struct" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aln_conservation_struct" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "aln_conservation_struct" "', argument " "3"" of type '" "vrna_md_t *""'"); 
    }
    arg3 = reinterpret_cast< vrna_md_t * >(argp3);
  }
  {
    try {
      result = my_aln_conservation_struct(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aln_conservation_col(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  vrna_md_t *arg2 = NULL ;
  unsigned int arg3 = VRNA_MEASURE_SHANNON_ENTROPY ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"md",  (char *)"options",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:aln_conservation_col", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aln_conservation_col" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "aln_conservation_col" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aln_conservation_col" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = my_aln_conservation_col(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_standard(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  enum MOVE_TYPE arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int temp1 ;
  int res1 = SWIG_TMPOBJ ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"seq",  (char *)"struc",  (char *)"type",  (char *)"verbosity_level",  (char *)"shifts",  (char *)"noLP",  NULL 
  };
  char *result = 0 ;
  
  arg1 = &temp1;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:move_standard", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  res2 = SWIG_AsCharPtrAndSize(obj0, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "move_standard" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj1, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "move_standard" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(obj2, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "move_standard" "', argument " "4"" of type '" "enum MOVE_TYPE""'");
  } 
  arg4 = static_cast< enum MOVE_TYPE >(val4);
  ecode5 = SWIG_AsVal_int(obj3, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "move_standard" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj4, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "move_standard" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj5, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "move_standard" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  {
    try {
      result = (char *)my_move_standard(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_int, new_flags), 0);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  free(result);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_struct_en_energy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _struct_en *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "struct_en_energy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__struct_en, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "struct_en_energy_set" "', argument " "1"" of type '" "_struct_en *""'"); 
  }
  arg1 = reinterpret_cast< _struct_en * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "struct_en_energy_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->energy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_struct_en_energy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _struct_en *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__struct_en, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "struct_en_energy_get" "', argument " "1"" of type '" "_struct_en *""'"); 
  }
  arg1 = reinterpret_cast< _struct_en * >(argp1);
  result = (int) ((arg1)->energy);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_struct_en_structure_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _struct_en *arg1 = 0 ;
  short *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "struct_en_structure_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__struct_en, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "struct_en_structure_set" "', argument " "1"" of type '" "_struct_en *""'"); 
  }
  arg1 = reinterpret_cast< _struct_en * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_short, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "struct_en_structure_set" "', argument " "2"" of type '" "short *""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  if (arg1) (arg1)->structure = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_struct_en_structure_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _struct_en *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__struct_en, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "struct_en_structure_get" "', argument " "1"" of type '" "_struct_en *""'"); 
  }
  arg1 = reinterpret_cast< _struct_en * >(argp1);
  result = (short *) ((arg1)->structure);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_struct_en(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _struct_en *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_struct_en", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (_struct_en *)new _struct_en();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__struct_en, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_struct_en(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  _struct_en *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__struct_en, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_struct_en" "', argument " "1"" of type '" "_struct_en *""'"); 
  }
  arg1 = reinterpret_cast< _struct_en * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *struct_en_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p__struct_en, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *struct_en_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_filename_sanitize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "filename_sanitize" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_filename_sanitize(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_filename_sanitize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  char arg2 ;
  char val2 ;
  int ecode2 = 0 ;
  std::string result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "filename_sanitize" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_char(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "filename_sanitize" "', argument " "2"" of type '" "char""'");
  } 
  arg2 = static_cast< char >(val2);
  {
    try {
      result = my_filename_sanitize(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_filename_sanitize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "filename_sanitize", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_filename_sanitize__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_filename_sanitize__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'filename_sanitize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_filename_sanitize(std::string)\n"
    "    my_filename_sanitize(std::string,char)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_log_cb_add_pycallback(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  PyObject *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  vrna_log_levels_e arg4 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"PyFunc",  (char *)"data",  (char *)"PyFuncOrNone",  (char *)"level",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:log_cb_add_pycallback", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    if (!PyCallable_Check(obj0)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg1 = obj0;
  }
  {
    arg2 = obj1;
  }
  {
    if(obj2 != Py_None){
      if (!PyCallable_Check(obj2)) {
        PyErr_SetString(PyExc_TypeError, "Need a callable object!");
        return NULL;
      }
    }
    arg3 = obj2;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "log_cb_add_pycallback" "', argument " "4"" of type '" "vrna_log_levels_e""'");
  } 
  arg4 = static_cast< vrna_log_levels_e >(val4);
  {
    try {
      result = (unsigned int)log_cb_add_pycallback(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_cb_add(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  PyObject *arg1 = 0 ;
  PyObject *arg2 = Py_None ;
  PyObject *arg3 = Py_None ;
  vrna_log_levels_e arg4 = VRNA_LOG_LEVEL_WARNING ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"callback",  (char *)"data",  (char *)"data_release",  (char *)"level",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:log_cb_add", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    if (!PyCallable_Check(obj0)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg1 = obj0;
  }
  if (obj1) {
    {
      arg2 = obj1;
    }
  }
  if (obj2) {
    {
      if(obj2 != Py_None){
        if (!PyCallable_Check(obj2)) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
          return NULL;
        }
      }
      arg3 = obj2;
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "log_cb_add" "', argument " "4"" of type '" "vrna_log_levels_e""'");
    } 
    arg4 = static_cast< vrna_log_levels_e >(val4);
  }
  {
    try {
      result = (unsigned int)log_cb_add(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_level(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_log_levels_e result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "log_level", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_log_levels_e)vrna_log_level();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_level_set(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_log_levels_e arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"level",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:log_level_set", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "log_level_set" "', argument " "1"" of type '" "vrna_log_levels_e""'");
  } 
  arg1 = static_cast< vrna_log_levels_e >(val1);
  {
    try {
      result = (int)vrna_log_level_set(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  unsigned int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "log_options", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (unsigned int)vrna_log_options();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_options_set(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"options",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:log_options_set", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "log_options_set" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  {
    try {
      vrna_log_options_set(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_fp(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  FILE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "log_fp", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (FILE *)vrna_log_fp();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_fp_set(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  FILE *arg1 = 0 ;
  PyObject *pyfile1 = NULL ;
  long start_position1 = -1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"fp",  NULL 
  };
  
  arg1 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:log_fp_set", kwnames, &obj0)) SWIG_fail;
  if(obj0 == Py_None){
    arg1 = NULL;
  } else {
    pyfile1 = obj0;
    arg1 = obj_to_file(obj0, &start_position1);
  }
  if (arg1 == NULL) {
    /* The generated wrapper function raises TypeError on mismatching types. */
    SWIG_exception_fail(SWIG_TypeError, "in method '" "log_fp_set" "', argument "
      "1"" of type '" "FILE *""'");
  }
  {
    try {
      vrna_log_fp_set(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "log_fp_set" "', argument "
      "1"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "log_fp_set" "', argument "
      "1"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_cb_num(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  size_t result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "log_cb_num", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = vrna_log_cb_num();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_log_reset(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "log_reset", 0, 0, 0)) SWIG_fail;
  {
    try {
      vrna_log_reset();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_xy_coordinates(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  COORDINATE *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:get_xy_coordinates", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_xy_coordinates" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (COORDINATE *)get_xy_coordinates((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_simple_xy_coordinates__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< COORDINATE,std::allocator< COORDINATE > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "simple_xy_coordinates" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_simple_xy_coordinates(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< COORDINATE,std::allocator< COORDINATE > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simple_circplot_coordinates(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"arg1",  NULL 
  };
  std::vector< COORDINATE,std::allocator< COORDINATE > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:simple_circplot_coordinates", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "simple_circplot_coordinates" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_simple_circplot_coordinates(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< COORDINATE,std::allocator< COORDINATE > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_naview_xy_coordinates(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"arg1",  NULL 
  };
  std::vector< COORDINATE,std::allocator< COORDINATE > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:naview_xy_coordinates", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "naview_xy_coordinates" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_naview_xy_coordinates(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< COORDINATE,std::allocator< COORDINATE > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_plot_layout(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 = VRNA_PLOT_TYPE_DEFAULT ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  (char *)"plot_type",  NULL 
  };
  vrna_plot_layout_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_plot_layout", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_plot_layout" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_plot_layout" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (vrna_plot_layout_t *)new_vrna_plot_layout_t(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_layout_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_plot_layout(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_layout_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_layout_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_plot_layout" "', argument " "1"" of type '" "vrna_plot_layout_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_layout_t * >(argp1);
  {
    try {
      delete_vrna_plot_layout_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *plot_layout_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_plot_layout_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *plot_layout_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_plot_options_puzzler_checkAncestorIntersections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_options_puzzler_checkAncestorIntersections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_checkAncestorIntersections_set" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plot_options_puzzler_checkAncestorIntersections_set" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  if (arg1) (arg1)->checkAncestorIntersections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_checkAncestorIntersections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_checkAncestorIntersections_get" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  result = (short) ((arg1)->checkAncestorIntersections);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_checkSiblingIntersections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_options_puzzler_checkSiblingIntersections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_checkSiblingIntersections_set" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plot_options_puzzler_checkSiblingIntersections_set" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  if (arg1) (arg1)->checkSiblingIntersections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_checkSiblingIntersections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_checkSiblingIntersections_get" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  result = (short) ((arg1)->checkSiblingIntersections);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_checkExteriorIntersections_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_options_puzzler_checkExteriorIntersections_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_checkExteriorIntersections_set" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plot_options_puzzler_checkExteriorIntersections_set" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  if (arg1) (arg1)->checkExteriorIntersections = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_checkExteriorIntersections_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_checkExteriorIntersections_get" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  result = (short) ((arg1)->checkExteriorIntersections);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_allowFlipping_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_options_puzzler_allowFlipping_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_allowFlipping_set" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plot_options_puzzler_allowFlipping_set" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  if (arg1) (arg1)->allowFlipping = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_allowFlipping_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_allowFlipping_get" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  result = (short) ((arg1)->allowFlipping);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_optimize_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  short val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_options_puzzler_optimize_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_optimize_set" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  ecode2 = SWIG_AsVal_short(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plot_options_puzzler_optimize_set" "', argument " "2"" of type '" "short""'");
  } 
  arg2 = static_cast< short >(val2);
  if (arg1) (arg1)->optimize = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_optimize_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  short result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_optimize_get" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  result = (short) ((arg1)->optimize);
  resultobj = SWIG_From_short(static_cast< short >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_options_puzzler_plot_options_puzzler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_plot_options_puzzler_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_options_puzzler_plot_options_puzzler" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  {
    try {
      result = (vrna_plot_options_puzzler_t *)vrna_plot_options_puzzler_t_vrna_plot_options_puzzler_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_plot_options_puzzler(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_options_puzzler_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_options_puzzler_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_plot_options_puzzler" "', argument " "1"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp1);
  {
    try {
      delete_vrna_plot_options_puzzler_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *plot_options_puzzler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_plot_options_puzzler_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *_wrap_plot_layout_simple(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  vrna_plot_layout_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:plot_layout_simple", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_layout_simple" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (vrna_plot_layout_t *)vrna_plot_layout_simple((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_layout_t, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_layout_naview(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  vrna_plot_layout_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:plot_layout_naview", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_layout_naview" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (vrna_plot_layout_t *)vrna_plot_layout_naview((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_layout_t, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_layout_circular(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  vrna_plot_layout_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:plot_layout_circular", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_layout_circular" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (vrna_plot_layout_t *)vrna_plot_layout_circular((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_layout_t, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_layout_turtle(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  vrna_plot_layout_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:plot_layout_turtle", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_layout_turtle" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (vrna_plot_layout_t *)vrna_plot_layout_turtle((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_layout_t, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_layout_puzzler(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  vrna_plot_options_puzzler_t *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  (char *)"options",  NULL 
  };
  vrna_plot_layout_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:plot_layout_puzzler", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_layout_puzzler" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_plot_options_puzzler_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plot_layout_puzzler" "', argument " "2"" of type '" "vrna_plot_options_puzzler_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_plot_options_puzzler_t * >(argp2);
  {
    try {
      result = (vrna_plot_layout_t *)vrna_plot_layout_puzzler((char const *)arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_layout_t, SWIG_POINTER_OWN |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_COORDINATE_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  COORDINATE *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  COORDINATE *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:COORDINATE_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_get" "', argument " "1"" of type '" "COORDINATE *""'"); 
  }
  arg1 = reinterpret_cast< COORDINATE * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "COORDINATE_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (COORDINATE *)COORDINATE_get(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_COORDINATE_X_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  COORDINATE *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "COORDINATE_X_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_X_set" "', argument " "1"" of type '" "COORDINATE *""'"); 
  }
  arg1 = reinterpret_cast< COORDINATE * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "COORDINATE_X_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->X = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_COORDINATE_X_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  COORDINATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_X_get" "', argument " "1"" of type '" "COORDINATE *""'"); 
  }
  arg1 = reinterpret_cast< COORDINATE * >(argp1);
  result = (float) ((arg1)->X);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_COORDINATE_Y_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  COORDINATE *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "COORDINATE_Y_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_Y_set" "', argument " "1"" of type '" "COORDINATE *""'"); 
  }
  arg1 = reinterpret_cast< COORDINATE * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "COORDINATE_Y_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->Y = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_COORDINATE_Y_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  COORDINATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_COORDINATE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "COORDINATE_Y_get" "', argument " "1"" of type '" "COORDINATE *""'"); 
  }
  arg1 = reinterpret_cast< COORDINATE * >(argp1);
  result = (float) ((arg1)->Y);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_COORDINATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  COORDINATE *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_COORDINATE", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (COORDINATE *)new COORDINATE();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_COORDINATE, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_COORDINATE(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  COORDINATE *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_COORDINATE, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_COORDINATE" "', argument " "1"" of type '" "COORDINATE *""'"); 
  }
  arg1 = reinterpret_cast< COORDINATE * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *COORDINATE_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_COORDINATE, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *COORDINATE_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_rna_plot_type_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""rna_plot_type""' of type '""int""'");
    }
    rna_plot_type = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_rna_plot_type_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(rna_plot_type));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_simple_xy_coordinates__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "simple_xy_coordinates" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "simple_xy_coordinates" "', argument " "2"" of type '" "float *""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "simple_xy_coordinates" "', argument " "3"" of type '" "float *""'"); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  {
    try {
      result = (int)simple_xy_coordinates(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_simple_xy_coordinates(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "simple_xy_coordinates", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_simple_xy_coordinates__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_short, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_simple_xy_coordinates__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'simple_xy_coordinates'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_simple_xy_coordinates(std::string)\n"
    "    simple_xy_coordinates(short *,float *,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_my_PS_rna_plot_snoop_a(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  std::vector< int,std::allocator< int > > arg4 ;
  std::vector< std::string,std::allocator< std::string > > arg5 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"structure",  (char *)"filename",  (char *)"relative_access",  (char *)"seqs",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:my_PS_rna_plot_snoop_a", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "my_PS_rna_plot_snoop_a" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "my_PS_rna_plot_snoop_a" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "my_PS_rna_plot_snoop_a" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "my_PS_rna_plot_snoop_a" "', argument " "4"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj4, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "my_PS_rna_plot_snoop_a" "', argument " "5"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)my_PS_rna_plot_snoop_a(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_PS_rnaplot__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  vrna_md_t *arg4 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "file_PS_rnaplot" "', argument " "4"" of type '" "vrna_md_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_md_t * >(argp4);
  {
    try {
      result = (int)file_PS_rnaplot(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_PS_rnaplot__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)file_PS_rnaplot(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_PS_rnaplot(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "file_PS_rnaplot", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_file_PS_rnaplot__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_vrna_md_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_file_PS_rnaplot__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'file_PS_rnaplot'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    file_PS_rnaplot(std::string,std::string,std::string,vrna_md_t *)\n"
    "    file_PS_rnaplot(std::string,std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_file_PS_rnaplot_a__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  vrna_md_t *arg6 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "file_PS_rnaplot_a" "', argument " "6"" of type '" "vrna_md_t *""'"); 
  }
  arg6 = reinterpret_cast< vrna_md_t * >(argp6);
  {
    try {
      result = (int)file_PS_rnaplot_a(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_PS_rnaplot_a__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string arg4 ;
  std::string arg5 ;
  int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[4], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_rnaplot_a" "', argument " "5"" of type '" "std::string""'"); 
    }
    arg5 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)file_PS_rnaplot_a(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_PS_rnaplot_a(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "file_PS_rnaplot_a", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 5) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_file_PS_rnaplot_a__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_vrna_md_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_file_PS_rnaplot_a__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'file_PS_rnaplot_a'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    file_PS_rnaplot_a(std::string,std::string,std::string,std::string,std::string,vrna_md_t *)\n"
    "    file_PS_rnaplot_a(std::string,std::string,std::string,std::string,std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_plot_data_pre_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_data_pre_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_pre_set" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plot_data_pre_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->pre;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->pre = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->pre = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_data_pre_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_pre_get" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  result = (char *) ((arg1)->pre);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_data_post_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_data_post_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_post_set" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plot_data_post_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->post;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->post = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->post = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_data_post_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_post_get" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  result = (char *) ((arg1)->post);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_data_md_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  vrna_md_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_data_md_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_md_set" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_vrna_md_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "plot_data_md_set" "', argument " "2"" of type '" "vrna_md_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  if (arg1) (arg1)->md = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_data_md_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_md_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_md_get" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  result = (vrna_md_t *) ((arg1)->md);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_md_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_data_options_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "plot_data_options_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_options_set" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "plot_data_options_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->options = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_data_options_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "plot_data_options_get" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  result = (unsigned int) ((arg1)->options);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_plot_data(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 = "" ;
  std::string arg2 = "" ;
  vrna_md_t *arg3 = NULL ;
  unsigned int arg4 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"pre",  (char *)"post",  (char *)"md",  (char *)"options",  NULL 
  };
  vrna_plot_data_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOOO:new_plot_data", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  if (obj0) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj0, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_plot_data" "', argument " "1"" of type '" "std::string""'"); 
      }
      arg1 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj1) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj1, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_plot_data" "', argument " "2"" of type '" "std::string""'"); 
      }
      arg2 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_plot_data" "', argument " "3"" of type '" "vrna_md_t *""'"); 
    }
    arg3 = reinterpret_cast< vrna_md_t * >(argp3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_plot_data" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (vrna_plot_data_t *)new_vrna_plot_data_t(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_plot_data_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_plot_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_plot_data_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_plot_data_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_plot_data" "', argument " "1"" of type '" "vrna_plot_data_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_plot_data_t * >(argp1);
  {
    try {
      delete_vrna_plot_data_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *plot_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_plot_data_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *plot_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_plot_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  unsigned int arg4 = VRNA_FILE_FORMAT_PLOT_DEFAULT ;
  vrna_plot_layout_t *arg5 = NULL ;
  vrna_plot_data_t *arg6 = NULL ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"sequence",  (char *)"structure",  (char *)"file_format",  (char *)"layout",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:plot_structure", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "plot_structure" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_plot_layout_t, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plot_structure" "', argument " "5"" of type '" "vrna_plot_layout_t *""'"); 
    }
    arg5 = reinterpret_cast< vrna_plot_layout_t * >(argp5);
  }
  if (obj5) {
    res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "plot_structure" "', argument " "6"" of type '" "vrna_plot_data_t *""'"); 
    }
    arg6 = reinterpret_cast< vrna_plot_data_t * >(argp6);
  }
  {
    try {
      result = (int)my_plot_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_structure_eps(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  vrna_plot_layout_t *arg4 = NULL ;
  vrna_plot_data_t *arg5 = NULL ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"sequence",  (char *)"structure",  (char *)"layout",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:plot_structure_eps", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_eps" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_eps" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_eps" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_plot_layout_t, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plot_structure_eps" "', argument " "4"" of type '" "vrna_plot_layout_t *""'"); 
    }
    arg4 = reinterpret_cast< vrna_plot_layout_t * >(argp4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plot_structure_eps" "', argument " "5"" of type '" "vrna_plot_data_t *""'"); 
    }
    arg5 = reinterpret_cast< vrna_plot_data_t * >(argp5);
  }
  {
    try {
      result = (int)my_plot_structure_eps(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_structure_svg(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  vrna_plot_layout_t *arg4 = NULL ;
  vrna_plot_data_t *arg5 = NULL ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"sequence",  (char *)"structure",  (char *)"layout",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:plot_structure_svg", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_svg" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_svg" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_svg" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_plot_layout_t, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plot_structure_svg" "', argument " "4"" of type '" "vrna_plot_layout_t *""'"); 
    }
    arg4 = reinterpret_cast< vrna_plot_layout_t * >(argp4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plot_structure_svg" "', argument " "5"" of type '" "vrna_plot_data_t *""'"); 
    }
    arg5 = reinterpret_cast< vrna_plot_data_t * >(argp5);
  }
  {
    try {
      result = (int)my_plot_structure_svg(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_structure_gml(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  vrna_plot_layout_t *arg4 = NULL ;
  vrna_plot_data_t *arg5 = NULL ;
  char arg6 = 'x' ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  char val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"sequence",  (char *)"structure",  (char *)"layout",  (char *)"data",  (char *)"option",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:plot_structure_gml", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_gml" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_gml" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_gml" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_plot_layout_t, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plot_structure_gml" "', argument " "4"" of type '" "vrna_plot_layout_t *""'"); 
    }
    arg4 = reinterpret_cast< vrna_plot_layout_t * >(argp4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plot_structure_gml" "', argument " "5"" of type '" "vrna_plot_data_t *""'"); 
    }
    arg5 = reinterpret_cast< vrna_plot_data_t * >(argp5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_char(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot_structure_gml" "', argument " "6"" of type '" "char""'");
    } 
    arg6 = static_cast< char >(val6);
  }
  {
    try {
      result = (int)my_plot_structure_gml(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_structure_ssv(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  vrna_plot_layout_t *arg4 = NULL ;
  vrna_plot_data_t *arg5 = NULL ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"sequence",  (char *)"structure",  (char *)"layout",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:plot_structure_ssv", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_ssv" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_ssv" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_ssv" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_plot_layout_t, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plot_structure_ssv" "', argument " "4"" of type '" "vrna_plot_layout_t *""'"); 
    }
    arg4 = reinterpret_cast< vrna_plot_layout_t * >(argp4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plot_structure_ssv" "', argument " "5"" of type '" "vrna_plot_data_t *""'"); 
    }
    arg5 = reinterpret_cast< vrna_plot_data_t * >(argp5);
  }
  {
    try {
      result = (int)my_plot_structure_ssv(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_structure_xrna(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  vrna_plot_layout_t *arg4 = NULL ;
  vrna_plot_data_t *arg5 = NULL ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"sequence",  (char *)"structure",  (char *)"layout",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:plot_structure_xrna", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_xrna" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_xrna" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_structure_xrna" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_plot_layout_t, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "plot_structure_xrna" "', argument " "4"" of type '" "vrna_plot_layout_t *""'"); 
    }
    arg4 = reinterpret_cast< vrna_plot_layout_t * >(argp4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_plot_data_t, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plot_structure_xrna" "', argument " "5"" of type '" "vrna_plot_data_t *""'"); 
    }
    arg5 = reinterpret_cast< vrna_plot_data_t * >(argp5);
  }
  {
    try {
      result = (int)my_plot_structure_xrna(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gmlRNA(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"ssfile",  (char *)"option",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:gmlRNA", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gmlRNA" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gmlRNA" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gmlRNA" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_char(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gmlRNA" "', argument " "4"" of type '" "char""'");
  } 
  arg4 = static_cast< char >(val4);
  {
    try {
      result = (int)gmlRNA(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_ssv_rna_plot(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"ssfile",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ssv_rna_plot", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ssv_rna_plot" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ssv_rna_plot" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ssv_rna_plot" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (int)ssv_rna_plot(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_svg_rna_plot(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"ssfile",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:svg_rna_plot", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "svg_rna_plot" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "svg_rna_plot" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "svg_rna_plot" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (int)svg_rna_plot(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_xrna_plot(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"ssfile",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:xrna_plot", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "xrna_plot" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "xrna_plot" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "xrna_plot" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (int)xrna_plot(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_rna_plot(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"file",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PS_rna_plot", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_rna_plot" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_rna_plot" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_rna_plot" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (int)PS_rna_plot(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_rna_plot_a(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  char *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"file",  (char *)"pre",  (char *)"post",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:PS_rna_plot_a", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_rna_plot_a" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_rna_plot_a" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_rna_plot_a" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_rna_plot_a" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PS_rna_plot_a" "', argument " "5"" of type '" "char *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    try {
      result = (int)PS_rna_plot_a(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_rna_plot_a_gquad(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  char *arg4 = 0 ;
  char *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"ssfile",  (char *)"pre",  (char *)"post",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:PS_rna_plot_a_gquad", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_rna_plot_a_gquad" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_rna_plot_a_gquad" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_rna_plot_a_gquad" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_rna_plot_a_gquad" "', argument " "4"" of type '" "char *""'");
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PS_rna_plot_a_gquad" "', argument " "5"" of type '" "char *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    try {
      result = (int)PS_rna_plot_a_gquad(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_PS_aln(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  std::vector< std::string,std::allocator< std::string > > arg3 ;
  std::string arg4 ;
  unsigned int arg5 = 0 ;
  unsigned int arg6 = 0 ;
  int arg7 = 0 ;
  unsigned int arg8 = 60 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"alignment",  (char *)"identifiers",  (char *)"structure",  (char *)"start",  (char *)"end",  (char *)"offset",  (char *)"columns",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OOOO:file_PS_aln", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_aln" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_aln" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_aln" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_PS_aln" "', argument " "4"" of type '" "std::string""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "file_PS_aln" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "file_PS_aln" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "file_PS_aln" "', argument " "7"" of type '" "int""'");
    } 
    arg7 = static_cast< int >(val7);
  }
  if (obj7) {
    ecode8 = SWIG_AsVal_unsigned_SS_int(obj7, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "file_PS_aln" "', argument " "8"" of type '" "unsigned int""'");
    } 
    arg8 = static_cast< unsigned int >(val8);
  }
  {
    try {
      result = (int)file_PS_aln(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6,arg7,arg8);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_plot_dp_EPS(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > arg3 ;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > arg4 = std::vector< vrna_ep_t >() ;
  vrna_dotplot_auxdata_t *arg5 = NULL ;
  unsigned int arg6 = VRNA_PLOT_PROBABILITIES_DEFAULT ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"sequence",  (char *)"upper_triangle",  (char *)"lower_triangle",  (char *)"auxdata",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:plot_dp_EPS", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_dp_EPS" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_dp_EPS" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_dp_EPS" "', argument " "3"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    {
      std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
      int res = swig::asptr(obj3, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "plot_dp_EPS" "', argument " "4"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_dotplot_auxdata_t, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "plot_dp_EPS" "', argument " "5"" of type '" "vrna_dotplot_auxdata_t *""'"); 
    }
    arg5 = reinterpret_cast< vrna_dotplot_auxdata_t * >(argp5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "plot_dp_EPS" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (int)plot_dp_EPS(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_color_dot_plot(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  vrna_cpair_t *arg2 = 0 ;
  char *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"pi",  (char *)"filename",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:PS_color_dot_plot", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_color_dot_plot" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_cpair_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_color_dot_plot" "', argument " "2"" of type '" "vrna_cpair_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_cpair_t * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_color_dot_plot" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  {
    try {
      result = (int)PS_color_dot_plot(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_color_dot_plot_turn(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  vrna_cpair_t *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"seq",  (char *)"pi",  (char *)"filename",  (char *)"winSize",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:PS_color_dot_plot_turn", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_color_dot_plot_turn" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_cpair_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_color_dot_plot_turn" "', argument " "2"" of type '" "vrna_cpair_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_cpair_t * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_color_dot_plot_turn" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PS_color_dot_plot_turn" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (int)PS_color_dot_plot_turn(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_dot_plot_turn(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  vrna_ep_t *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"seq",  (char *)"pl",  (char *)"filename",  (char *)"winSize",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:PS_dot_plot_turn", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_dot_plot_turn" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_dot_plot_turn" "', argument " "2"" of type '" "vrna_ep_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_ep_t * >(argp2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_dot_plot_turn" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PS_dot_plot_turn" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (int)PS_dot_plot_turn(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_dot_plot_list(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  vrna_ep_t *arg3 = 0 ;
  vrna_ep_t *arg4 = 0 ;
  char *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"seq",  (char *)"filename",  (char *)"pl",  (char *)"mf",  (char *)"comment",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:PS_dot_plot_list", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_dot_plot_list" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_dot_plot_list" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PS_dot_plot_list" "', argument " "3"" of type '" "vrna_ep_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_ep_t * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "PS_dot_plot_list" "', argument " "4"" of type '" "vrna_ep_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_ep_t * >(argp4);
  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "PS_dot_plot_list" "', argument " "5"" of type '" "char *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  {
    try {
      result = (int)PS_dot_plot_list(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_PS_dot_plot(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"file",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:PS_dot_plot", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PS_dot_plot" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PS_dot_plot" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (int)PS_dot_plot(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_hc_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_hc_type_e result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hc_type_get" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  result = (vrna_hc_type_e)(vrna_hc_type_e) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hc_n_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hc_n_get" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  {
    try {
      result = (unsigned int)vrna_hc_t_n_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hc_mx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned char > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hc_mx_get" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  {
    try {
      result = (var_array< unsigned char > *)vrna_hc_t_mx_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_char_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hc_up_ext_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hc_up_ext_get" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_hc_t_up_ext_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hc_up_hp_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hc_up_hp_get" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_hc_t_up_hp_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hc_up_int_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hc_up_int_get" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_hc_t_up_int_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_hc_up_ml_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hc_up_ml_get" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_hc_t_up_ml_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_hc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_hc", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_hc_t *)new vrna_hc_t();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_hc_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_hc(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_hc_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_hc_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_hc" "', argument " "1"" of type '" "vrna_hc_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_hc_t * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *hc_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_hc_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *hc_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_sc_mod_param(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"json",  (char *)"md",  NULL 
  };
  vrna_sc_mod_param_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:new_sc_mod_param", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_sc_mod_param" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_sc_mod_param" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = (vrna_sc_mod_param_s *)new_vrna_sc_mod_param_s(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_sc_mod_param_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_sc_mod_param(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_sc_mod_param_s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_sc_mod_param_s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_sc_mod_param" "', argument " "1"" of type '" "vrna_sc_mod_param_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_sc_mod_param_s * >(argp1);
  {
    try {
      delete_vrna_sc_mod_param_s(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *sc_mod_param_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_sc_mod_param_s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *sc_mod_param_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_sc_mod_read_from_jsonfile(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"md",  NULL 
  };
  vrna_sc_mod_param_t result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:sc_mod_read_from_jsonfile", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "sc_mod_read_from_jsonfile" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sc_mod_read_from_jsonfile" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = (vrna_sc_mod_param_t)my_sc_mod_read_from_jsonfile(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_sc_mod_param_s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sc_mod_read_from_json(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"json",  (char *)"md",  NULL 
  };
  vrna_sc_mod_param_t result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:sc_mod_read_from_json", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "sc_mod_read_from_json" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "sc_mod_read_from_json" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = (vrna_sc_mod_param_t)my_sc_mod_read_from_json(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_sc_mod_param_s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sc_mod_parameters_free(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_sc_mod_param_t arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"params",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:sc_mod_parameters_free", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_sc_mod_param_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sc_mod_parameters_free" "', argument " "1"" of type '" "vrna_sc_mod_param_t""'"); 
  }
  arg1 = reinterpret_cast< vrna_sc_mod_param_t >(argp1);
  {
    try {
      vrna_sc_mod_parameters_free(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_linear(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = Py_None ;
  PyObject *arg5 = Py_None ;
  unsigned int arg6 = VRNA_PROBING_DATA_DEFAULT ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"data",  (char *)"data_weights",  (char *)"strategy_cb",  (char *)"strategy_cb_options",  (char *)"strategy_cb_options_free",  (char *)"options",  NULL 
  };
  vrna_probing_data_t result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:probing_data_linear", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_linear" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_linear" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    arg3 = obj2;
  }
  if (obj3) {
    {
      arg4 = obj3;
    }
  }
  if (obj4) {
    {
      arg5 = obj4;
    }
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "probing_data_linear" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (vrna_probing_data_t)probing_data_linear(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  double arg3 ;
  PyObject *arg4 = Py_None ;
  PyObject *arg5 = Py_None ;
  PyObject *arg6 = Py_None ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 6)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_probing_data" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_probing_data" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  if (swig_obj[3]) {
    {
      if(swig_obj[3] != Py_None){
        if (!PyCallable_Check(swig_obj[3])) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
          return NULL;
        }
      }
      arg4 = swig_obj[3];
    }
  }
  if (swig_obj[4]) {
    {
      arg5 = swig_obj[4];
    }
  }
  if (swig_obj[5]) {
    {
      if(swig_obj[5] != Py_None){
        if (!PyCallable_Check(swig_obj[5])) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
          return NULL;
        }
      }
      arg6 = swig_obj[5];
    }
  }
  {
    try {
      result = (vrna_probing_data_s *)new_vrna_probing_data_s__SWIG_0(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  std::string arg3 = VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion ;
  double arg4 = VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_probing_data" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (swig_obj[2]) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(swig_obj[2], &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "3"" of type '" "std::string""'"); 
      }
      arg3 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_probing_data" "', argument " "4"" of type '" "double""'");
    } 
    arg4 = static_cast< double >(val4);
  }
  {
    try {
      result = (vrna_probing_data_s *)new_vrna_probing_data_s__SWIG_1(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  unsigned int arg3 = VRNA_PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT ;
  std::vector< double,std::allocator< double > > arg4 = {
    
  } ;
  std::vector< double,std::allocator< double > > arg5 = {
    
  } ;
  PyObject *arg6 = Py_None ;
  PyObject *arg7 = Py_None ;
  PyObject *arg8 = Py_None ;
  double val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 8)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_probing_data" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_probing_data" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  if (swig_obj[3]) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(swig_obj[3], &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (swig_obj[4]) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(swig_obj[4], &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg5 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (swig_obj[5]) {
    {
      if(swig_obj[5] != Py_None){
        if (!PyCallable_Check(swig_obj[5])) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
          return NULL;
        }
      }
      arg6 = swig_obj[5];
    }
  }
  if (swig_obj[6]) {
    {
      arg7 = swig_obj[6];
    }
  }
  if (swig_obj[7]) {
    {
      if(swig_obj[7] != Py_None){
        if (!PyCallable_Check(swig_obj[7])) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
          return NULL;
        }
      }
      arg8 = swig_obj[7];
    }
  }
  {
    try {
      result = (vrna_probing_data_s *)new_vrna_probing_data_s__SWIG_2(SWIG_STD_MOVE(arg1),arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),arg6,arg7,arg8);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  double arg3 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_probing_data" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_probing_data" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (vrna_probing_data_s *)new_vrna_probing_data_s__SWIG_3(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (vrna_probing_data_s *)new_vrna_probing_data_s__SWIG_4(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data__SWIG_5(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::vector< std::string,std::allocator< std::string > > arg3 = std::vector< std::string >() ;
  std::vector< double,std::allocator< double > > arg4 = std::vector< double >() ;
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    {
      std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
      int res = swig::asptr(swig_obj[2], &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
      }
      arg3 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (swig_obj[3]) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(swig_obj[3], &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  {
    try {
      result = (vrna_probing_data_s *)new_vrna_probing_data_s__SWIG_5(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data__SWIG_6(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  unsigned char arg3 ;
  std::vector< double,std::allocator< double > > arg4 = {
    
  } ;
  std::vector< double,std::allocator< double > > arg5 = {
    
  } ;
  double val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_probing_data" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_probing_data" "', argument " "3"" of type '" "unsigned char""'");
  } 
  arg3 = static_cast< unsigned char >(val3);
  if (swig_obj[3]) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(swig_obj[3], &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (swig_obj[4]) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(swig_obj[4], &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_probing_data" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg5 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  {
    try {
      result = (vrna_probing_data_s *)new_vrna_probing_data_s__SWIG_6(SWIG_STD_MOVE(arg1),arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_probing_data(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_probing_data", 0, 8, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_probing_data__SWIG_1(self, argc, argv);
        }
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_probing_data__SWIG_1(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_probing_data__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 8)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_probing_data__SWIG_2(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_probing_data__SWIG_2(self, argc, argv);
          }
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_probing_data__SWIG_2(self, argc, argv);
            }
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              if (argc <= 5) {
                return _wrap_new_probing_data__SWIG_2(self, argc, argv);
              }
              {
                _v = PyCallable_Check(argv[5]) || argv[5] == Py_None;
              }
              if (_v) {
                if (argc <= 6) {
                  return _wrap_new_probing_data__SWIG_2(self, argc, argv);
                }
                _v = (argv[6] != 0);
                if (_v) {
                  if (argc <= 7) {
                    return _wrap_new_probing_data__SWIG_2(self, argc, argv);
                  }
                  {
                    _v = PyCallable_Check(argv[7]) || argv[7] == Py_None;
                  }
                  if (_v) {
                    return _wrap_new_probing_data__SWIG_2(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_probing_data__SWIG_5(self, argc, argv);
        }
        int res = swig::asptr(argv[2], (std::vector< std::string,std::allocator< std::string > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_probing_data__SWIG_5(self, argc, argv);
          }
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_probing_data__SWIG_5(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_probing_data__SWIG_6(self, argc, argv);
          }
          int res = swig::asptr(argv[3], (std::vector< double,std::allocator< double > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_probing_data__SWIG_6(self, argc, argv);
            }
            int res = swig::asptr(argv[4], (std::vector< double,std::allocator< double > >**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_probing_data__SWIG_6(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 6)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_probing_data__SWIG_0(self, argc, argv);
          }
          {
            _v = PyCallable_Check(argv[3]) || argv[3] == Py_None;
          }
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_probing_data__SWIG_0(self, argc, argv);
            }
            _v = (argv[4] != 0);
            if (_v) {
              if (argc <= 5) {
                return _wrap_new_probing_data__SWIG_0(self, argc, argv);
              }
              {
                _v = PyCallable_Check(argv[5]) || argv[5] == Py_None;
              }
              if (_v) {
                return _wrap_new_probing_data__SWIG_0(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_probing_data__SWIG_3(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_probing_data__SWIG_4(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_probing_data'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_probing_data_s::vrna_probing_data_s(std::vector< double,std::allocator< double > >,double,double,PyObject *,PyObject *,PyObject *)\n"
    "    vrna_probing_data_s::vrna_probing_data_s(std::vector< double,std::allocator< double > >,double,std::string,double)\n"
    "    vrna_probing_data_s::vrna_probing_data_s(std::vector< double,std::allocator< double > >,double,unsigned int,std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > >,PyObject *,PyObject *,PyObject *)\n"
    "    vrna_probing_data_s::vrna_probing_data_s(std::vector< double,std::allocator< double > >,double,double)\n"
    "    vrna_probing_data_s::vrna_probing_data_s(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > >)\n"
    "    vrna_probing_data_s::vrna_probing_data_s(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,std::vector< double,std::allocator< double > >,std::vector< std::string,std::allocator< std::string > >,std::vector< double,std::allocator< double > >)\n"
    "    vrna_probing_data_s::vrna_probing_data_s(std::vector< double,std::allocator< double > >,double,unsigned char,std::vector< double,std::allocator< double > >,std::vector< double,std::allocator< double > >)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_probing_data(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_probing_data_s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_probing_data" "', argument " "1"" of type '" "vrna_probing_data_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_probing_data_s * >(argp1);
  {
    try {
      delete_vrna_probing_data_s(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_probing_data_linear_num(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_probing_data_s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_probing_data_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probing_data_probing_data_linear_num" "', argument " "1"" of type '" "vrna_probing_data_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_probing_data_s * >(argp1);
  {
    try {
      result = (unsigned int)vrna_probing_data_s_probing_data_linear_num(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_probing_data_linear_raw(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_probing_data_s *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"pos",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:probing_data_probing_data_linear_raw", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_probing_data_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probing_data_probing_data_linear_raw" "', argument " "1"" of type '" "vrna_probing_data_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_probing_data_s * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "probing_data_probing_data_linear_raw" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = vrna_probing_data_s_probing_data_linear_raw(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_probing_data_linear_weight(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_probing_data_s *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"pos",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:probing_data_probing_data_linear_weight", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_probing_data_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probing_data_probing_data_linear_weight" "', argument " "1"" of type '" "vrna_probing_data_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_probing_data_s * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "probing_data_probing_data_linear_weight" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = vrna_probing_data_s_probing_data_linear_weight(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_probing_data_linear_energies(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_probing_data_s *arg1 = 0 ;
  unsigned int arg2 ;
  vrna_fold_compound_t *arg3 = 0 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"pos",  (char *)"fc",  (char *)"target",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:probing_data_probing_data_linear_energies", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_probing_data_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probing_data_probing_data_linear_energies" "', argument " "1"" of type '" "vrna_probing_data_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_probing_data_s * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "probing_data_probing_data_linear_energies" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "probing_data_probing_data_linear_energies" "', argument " "3"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_fold_compound_t * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "probing_data_probing_data_linear_energies" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = vrna_probing_data_s_probing_data_linear_energies(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *probing_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_probing_data_s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *probing_data_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_probing_data_deigan(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  double arg3 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"reactivities",  (char *)"m",  (char *)"b",  NULL 
  };
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:probing_data_deigan", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_deigan" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "probing_data_deigan" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "probing_data_deigan" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (vrna_probing_data_s *)probing_data_deigan(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_deigan_comparative(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  unsigned int arg4 = VRNA_PROBING_METHOD_MULTI_PARAMS_0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"reactivities",  (char *)"ms",  (char *)"bs",  (char *)"multi_params",  NULL 
  };
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:probing_data_deigan_comparative", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_deigan_comparative" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_deigan_comparative" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_deigan_comparative" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "probing_data_deigan_comparative" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (vrna_probing_data_s *)probing_data_deigan_comparative(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_zarringhalam(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  std::string arg3 = VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion ;
  double arg4 = VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability ;
  double val2 ;
  int ecode2 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"reactivities",  (char *)"beta",  (char *)"pr_conversion",  (char *)"pr_default",  NULL 
  };
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:probing_data_zarringhalam", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_zarringhalam" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "probing_data_zarringhalam" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (obj2) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj2, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_zarringhalam" "', argument " "3"" of type '" "std::string""'"); 
      }
      arg3 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_double(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "probing_data_zarringhalam" "', argument " "4"" of type '" "double""'");
    } 
    arg4 = static_cast< double >(val4);
  }
  {
    try {
      result = (vrna_probing_data_s *)probing_data_zarringhalam(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_zarringhalam_comparative(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::vector< std::string,std::allocator< std::string > > arg3 = std::vector< std::string >() ;
  std::vector< double,std::allocator< double > > arg4 = std::vector< double >() ;
  unsigned int arg5 = VRNA_PROBING_METHOD_MULTI_PARAMS_0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"reactivities",  (char *)"betas",  (char *)"pr_conversions",  (char *)"pr_defaults",  (char *)"multi_params",  NULL 
  };
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:probing_data_zarringhalam_comparative", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_zarringhalam_comparative" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_zarringhalam_comparative" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    {
      std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
      int res = swig::asptr(obj2, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_zarringhalam_comparative" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
      }
      arg3 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj3) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(obj3, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_zarringhalam_comparative" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "probing_data_zarringhalam_comparative" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = (vrna_probing_data_s *)probing_data_zarringhalam_comparative(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_eddy(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  double arg2 ;
  unsigned char arg3 = VRNA_PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT ;
  std::vector< double,std::allocator< double > > arg4 = {
    
  } ;
  std::vector< double,std::allocator< double > > arg5 = {
    
  } ;
  double val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"reactivities",  (char *)"temperature",  (char *)"options",  (char *)"unpaired_data",  (char *)"paired_data",  NULL 
  };
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOO:probing_data_eddy", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_eddy" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "probing_data_eddy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "probing_data_eddy" "', argument " "3"" of type '" "unsigned char""'");
    } 
    arg3 = static_cast< unsigned char >(val3);
  }
  if (obj3) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(obj3, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_eddy" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj4) {
    {
      std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
      int res = swig::asptr(obj4, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_eddy" "', argument " "5"" of type '" "std::vector< double,std::allocator< double > >""'"); 
      }
      arg5 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  {
    try {
      result = (vrna_probing_data_s *)probing_data_eddy(SWIG_STD_MOVE(arg1),arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_eddy_comparative(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg1 ;
  double arg2 ;
  unsigned char arg3 = VRNA_PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg4 = {
    
  } ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg5 = {
    
  } ;
  unsigned int arg6 = VRNA_PROBING_METHOD_MULTI_PARAMS_0 ;
  double val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"reactivities",  (char *)"temperature",  (char *)"options",  (char *)"unpaired_data",  (char *)"paired_data",  (char *)"multi_params",  NULL 
  };
  vrna_probing_data_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOOO:probing_data_eddy_comparative", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_eddy_comparative" "', argument " "1"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "probing_data_eddy_comparative" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "probing_data_eddy_comparative" "', argument " "3"" of type '" "unsigned char""'");
    } 
    arg3 = static_cast< unsigned char >(val3);
  }
  if (obj3) {
    {
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
      int res = swig::asptr(obj3, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_eddy_comparative" "', argument " "4"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj4) {
    {
      std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
      int res = swig::asptr(obj4, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "probing_data_eddy_comparative" "', argument " "5"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
      }
      arg5 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "probing_data_eddy_comparative" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (vrna_probing_data_s *)probing_data_eddy_comparative(SWIG_STD_MOVE(arg1),arg2,arg3,SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_probing_data_s, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_probing_data_free(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_probing_data_t arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"d",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:probing_data_free", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_probing_data_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "probing_data_free" "', argument " "1"" of type '" "vrna_probing_data_t""'"); 
  }
  arg1 = reinterpret_cast< vrna_probing_data_t >(argp1);
  {
    try {
      vrna_probing_data_free(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_structure_simple__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_simple" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_simple" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_structure_simple" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_structure_simple(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_circ_structure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_structure" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_circ_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_circ_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_gquad_structure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_gquad_structure" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_gquad_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_gquad_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_gquad_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_circ_gquad_structure__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_gquad_structure" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_gquad_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_circ_gquad_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_circ_gquad_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_structure_simple__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_simple" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_simple" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_structure_simple" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_structure_simple(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_structure_simple(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "eval_structure_simple", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_structure_simple__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_structure_simple__SWIG_0(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_structure_simple__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_structure_simple__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_structure_simple__SWIG_1(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_structure_simple__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'eval_structure_simple'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_eval_structure_simple(std::string,std::string,int,FILE *)\n"
    "    my_eval_structure_simple(std::vector< std::string,std::allocator< std::string > >,std::string,int,FILE *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_eval_circ_structure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_structure" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_circ_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_circ_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_circ_structure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "eval_circ_structure", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_circ_structure__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_circ_structure__SWIG_0(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_circ_structure__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_circ_structure__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_circ_structure__SWIG_1(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_circ_structure__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'eval_circ_structure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_eval_circ_structure(std::string,std::string,int,FILE *)\n"
    "    my_eval_circ_structure(std::vector< std::string,std::allocator< std::string > >,std::string,int,FILE *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_eval_gquad_structure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_gquad_structure" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_gquad_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_gquad_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_gquad_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_gquad_structure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "eval_gquad_structure", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_gquad_structure__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_gquad_structure__SWIG_0(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_gquad_structure__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_gquad_structure__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_gquad_structure__SWIG_1(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_gquad_structure__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'eval_gquad_structure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_eval_gquad_structure(std::string,std::string,int,FILE *)\n"
    "    my_eval_gquad_structure(std::vector< std::string,std::allocator< std::string > >,std::string,int,FILE *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_eval_circ_gquad_structure__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::string arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  float result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_gquad_structure" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_circ_gquad_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_circ_gquad_structure" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_eval_circ_gquad_structure(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_circ_gquad_structure" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_circ_gquad_structure(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "eval_circ_gquad_structure", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_circ_gquad_structure__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_circ_gquad_structure__SWIG_0(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_circ_gquad_structure__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_circ_gquad_structure__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_circ_gquad_structure__SWIG_1(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_circ_gquad_structure__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'eval_circ_gquad_structure'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_eval_circ_gquad_structure(std::string,std::string,int,FILE *)\n"
    "    my_eval_circ_gquad_structure(std::vector< std::string,std::allocator< std::string > >,std::string,int,FILE *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_eval_structure_pt_simple__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  int result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_pt_simple" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_pt_simple" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_structure_pt_simple" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (int)my_eval_structure_pt_simple(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_structure_pt_simple__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  var_array< short > *arg2 = 0 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  int result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_pt_simple" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eval_structure_pt_simple" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "eval_structure_pt_simple" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_structure_pt_simple" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (int)my_eval_structure_pt_simple(SWIG_STD_MOVE(arg1),(var_array< short > const &)*arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_structure_pt_simple__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::vector< int,std::allocator< int > > arg2 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  int result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_pt_simple" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_pt_simple" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_structure_pt_simple" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (int)my_eval_structure_pt_simple(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_structure_pt_simple__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  var_array< short > *arg2 = 0 ;
  int arg3 = VRNA_VERBOSITY_QUIET ;
  FILE *arg4 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  int result;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "eval_structure_pt_simple" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "eval_structure_pt_simple" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "eval_structure_pt_simple" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eval_structure_pt_simple" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (int)my_eval_structure_pt_simple(SWIG_STD_MOVE(arg1),(var_array< short > const &)*arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "eval_structure_pt_simple" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eval_structure_pt_simple(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "eval_structure_pt_simple", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_structure_pt_simple__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_structure_pt_simple__SWIG_1(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_structure_pt_simple__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_structure_pt_simple__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_structure_pt_simple__SWIG_0(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_structure_pt_simple__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_structure_pt_simple__SWIG_3(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_structure_pt_simple__SWIG_3(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_structure_pt_simple__SWIG_3(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 4)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_eval_structure_pt_simple__SWIG_2(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_eval_structure_pt_simple__SWIG_2(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_eval_structure_pt_simple__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'eval_structure_pt_simple'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_eval_structure_pt_simple(std::string,std::vector< int,std::allocator< int > >,int,FILE *)\n"
    "    my_eval_structure_pt_simple(std::string,var_array< short > const &,int,FILE *)\n"
    "    my_eval_structure_pt_simple(std::vector< std::string,std::allocator< std::string > >,std::vector< int,std::allocator< int > >,int,FILE *)\n"
    "    my_eval_structure_pt_simple(std::vector< std::string,std::allocator< std::string > >,var_array< short > const &,int,FILE *)\n");
  return 0;
}


SWIGINTERN int Swig_var_cut_point_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""cut_point""' of type '""int""'");
    }
    cut_point = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_cut_point_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(cut_point));
  return pyobj;
}


SWIGINTERN int Swig_var_eos_debug_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""eos_debug""' of type '""int""'");
    }
    eos_debug = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_eos_debug_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(eos_debug));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_energy_of_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"verbosity_level",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:energy_of_structure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_structure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_structure" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_structure" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (float)energy_of_structure((char const *)arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_circ_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"verbosity_level",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:energy_of_circ_structure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_circ_structure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_circ_structure" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_circ_structure" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (float)energy_of_circ_structure((char const *)arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_gquad_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"verbosity_level",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:energy_of_gquad_structure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_gquad_structure" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_gquad_structure" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_gquad_structure" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (float)energy_of_gquad_structure((char const *)arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_structure_pt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  int arg5 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"ptable",  (char *)"s",  (char *)"s1",  (char *)"verbosity_level",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:energy_of_structure_pt", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_structure_pt" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_structure_pt" "', argument " "2"" of type '" "short *""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_structure_pt" "', argument " "3"" of type '" "short *""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "energy_of_structure_pt" "', argument " "4"" of type '" "short *""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "energy_of_structure_pt" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (int)energy_of_structure_pt((char const *)arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_move(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  (char *)"m1",  (char *)"m2",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:energy_of_move", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_move" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_move" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "energy_of_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "energy_of_move" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (float)energy_of_move((char const *)arg1,(char const *)arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_move_pt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"pt",  (char *)"s",  (char *)"s1",  (char *)"m1",  (char *)"m2",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:energy_of_move_pt", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_move_pt" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_move_pt" "', argument " "2"" of type '" "short *""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_move_pt" "', argument " "3"" of type '" "short *""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "energy_of_move_pt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "energy_of_move_pt" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (int)energy_of_move_pt(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_loop_energy(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"ptable",  (char *)"s",  (char *)"s1",  (char *)"i",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:loop_energy", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "loop_energy" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "loop_energy" "', argument " "2"" of type '" "short *""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "loop_energy" "', argument " "3"" of type '" "short *""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "loop_energy" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (int)loop_energy(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_struct(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:energy_of_struct", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_struct" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_struct" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (float)energy_of_struct((char const *)arg1,(char const *)arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_struct_pt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  short *arg2 = 0 ;
  short *arg3 = 0 ;
  short *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"ptable",  (char *)"s",  (char *)"s1",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:energy_of_struct_pt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_struct_pt" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_struct_pt" "', argument " "2"" of type '" "short *""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "energy_of_struct_pt" "', argument " "3"" of type '" "short *""'"); 
  }
  arg3 = reinterpret_cast< short * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "energy_of_struct_pt" "', argument " "4"" of type '" "short *""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  {
    try {
      result = (int)energy_of_struct_pt((char const *)arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_energy_of_circ_struct(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"structure",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:energy_of_circ_struct", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "energy_of_circ_struct" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "energy_of_circ_struct" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (float)energy_of_circ_struct((char const *)arg1,(char const *)arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_Stem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  vrna_param_t *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"extLoop",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:E_Stem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_Stem" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_Stem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "E_Stem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "E_Stem" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "E_Stem" "', argument " "5"" of type '" "vrna_param_t *""'"); 
  }
  arg5 = reinterpret_cast< vrna_param_t * >(argp5);
  {
    try {
      result = (int)E_Stem(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_ExtLoop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  vrna_param_t *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:E_ExtLoop", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_ExtLoop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_ExtLoop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "E_ExtLoop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "E_ExtLoop" "', argument " "4"" of type '" "vrna_param_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_param_t * >(argp4);
  {
    try {
      result = (int)E_ExtLoop(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_E_ExtLoop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  vrna_exp_param_t *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"P",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:exp_E_ExtLoop", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "exp_E_ExtLoop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "exp_E_ExtLoop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "exp_E_ExtLoop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "exp_E_ExtLoop" "', argument " "4"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_exp_param_t * >(argp4);
  {
    try {
      result = (FLT_OR_DBL)exp_E_ExtLoop(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_E_Stem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  vrna_exp_param_t *arg5 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"extLoop",  (char *)"P",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:exp_E_Stem", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "exp_E_Stem" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "exp_E_Stem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "exp_E_Stem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "exp_E_Stem" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "exp_E_Stem" "', argument " "5"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg5 = reinterpret_cast< vrna_exp_param_t * >(argp5);
  {
    try {
      result = (FLT_OR_DBL)exp_E_Stem(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_Hairpin(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  char *arg5 = 0 ;
  vrna_param_t *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"size",  (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"string",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:E_Hairpin", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_Hairpin" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_Hairpin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "E_Hairpin" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "E_Hairpin" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "E_Hairpin" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "E_Hairpin" "', argument " "6"" of type '" "vrna_param_t *""'"); 
  }
  arg6 = reinterpret_cast< vrna_param_t * >(argp6);
  {
    try {
      result = (int)E_Hairpin(arg1,arg2,arg3,arg4,(char const *)arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_E_Hairpin(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  short arg3 ;
  short arg4 ;
  char *arg5 = 0 ;
  vrna_exp_param_t *arg6 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  short val3 ;
  int ecode3 = 0 ;
  short val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"u",  (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"string",  (char *)"P",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:exp_E_Hairpin", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "exp_E_Hairpin" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "exp_E_Hairpin" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_short(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "exp_E_Hairpin" "', argument " "3"" of type '" "short""'");
  } 
  arg3 = static_cast< short >(val3);
  ecode4 = SWIG_AsVal_short(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "exp_E_Hairpin" "', argument " "4"" of type '" "short""'");
  } 
  arg4 = static_cast< short >(val4);
  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "exp_E_Hairpin" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "exp_E_Hairpin" "', argument " "6"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg6 = reinterpret_cast< vrna_exp_param_t * >(argp6);
  {
    try {
      result = (FLT_OR_DBL)exp_E_Hairpin(arg1,arg2,arg3,arg4,(char const *)arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_IntLoop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  vrna_param_t *arg9 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"n1",  (char *)"n2",  (char *)"type",  (char *)"type_2",  (char *)"si1",  (char *)"sj1",  (char *)"sp1",  (char *)"sq1",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO:E_IntLoop", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_IntLoop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_IntLoop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "E_IntLoop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "E_IntLoop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "E_IntLoop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "E_IntLoop" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "E_IntLoop" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "E_IntLoop" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "E_IntLoop" "', argument " "9"" of type '" "vrna_param_t *""'"); 
  }
  arg9 = reinterpret_cast< vrna_param_t * >(argp9);
  {
    try {
      result = (int)E_IntLoop(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_E_IntLoop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  short arg5 ;
  short arg6 ;
  short arg7 ;
  short arg8 ;
  vrna_exp_param_t *arg9 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  short val5 ;
  int ecode5 = 0 ;
  short val6 ;
  int ecode6 = 0 ;
  short val7 ;
  int ecode7 = 0 ;
  short val8 ;
  int ecode8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"u1",  (char *)"u2",  (char *)"type",  (char *)"type2",  (char *)"si1",  (char *)"sj1",  (char *)"sp1",  (char *)"sq1",  (char *)"P",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO:exp_E_IntLoop", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "exp_E_IntLoop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "exp_E_IntLoop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "exp_E_IntLoop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "exp_E_IntLoop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_short(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "exp_E_IntLoop" "', argument " "5"" of type '" "short""'");
  } 
  arg5 = static_cast< short >(val5);
  ecode6 = SWIG_AsVal_short(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "exp_E_IntLoop" "', argument " "6"" of type '" "short""'");
  } 
  arg6 = static_cast< short >(val6);
  ecode7 = SWIG_AsVal_short(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "exp_E_IntLoop" "', argument " "7"" of type '" "short""'");
  } 
  arg7 = static_cast< short >(val7);
  ecode8 = SWIG_AsVal_short(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "exp_E_IntLoop" "', argument " "8"" of type '" "short""'");
  } 
  arg8 = static_cast< short >(val8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "exp_E_IntLoop" "', argument " "9"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg9 = reinterpret_cast< vrna_exp_param_t * >(argp9);
  {
    try {
      result = (FLT_OR_DBL)exp_E_IntLoop(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_IntLoop_Co(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  short arg8 ;
  short arg9 ;
  short arg10 ;
  short arg11 ;
  int arg12 ;
  vrna_param_t *arg13 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  short val8 ;
  int ecode8 = 0 ;
  short val9 ;
  int ecode9 = 0 ;
  short val10 ;
  int ecode10 = 0 ;
  short val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"type_2",  (char *)"i",  (char *)"j",  (char *)"p",  (char *)"q",  (char *)"cutpoint",  (char *)"si1",  (char *)"sj1",  (char *)"sp1",  (char *)"sq1",  (char *)"dangles",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOO:E_IntLoop_Co", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_IntLoop_Co" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_IntLoop_Co" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "E_IntLoop_Co" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "E_IntLoop_Co" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "E_IntLoop_Co" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "E_IntLoop_Co" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "E_IntLoop_Co" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_short(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "E_IntLoop_Co" "', argument " "8"" of type '" "short""'");
  } 
  arg8 = static_cast< short >(val8);
  ecode9 = SWIG_AsVal_short(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "E_IntLoop_Co" "', argument " "9"" of type '" "short""'");
  } 
  arg9 = static_cast< short >(val9);
  ecode10 = SWIG_AsVal_short(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "E_IntLoop_Co" "', argument " "10"" of type '" "short""'");
  } 
  arg10 = static_cast< short >(val10);
  ecode11 = SWIG_AsVal_short(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "E_IntLoop_Co" "', argument " "11"" of type '" "short""'");
  } 
  arg11 = static_cast< short >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "E_IntLoop_Co" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "E_IntLoop_Co" "', argument " "13"" of type '" "vrna_param_t *""'"); 
  }
  arg13 = reinterpret_cast< vrna_param_t * >(argp13);
  {
    try {
      result = (int)E_IntLoop_Co(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap___E_IntLoop_Co(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  short arg8 ;
  short arg9 ;
  short arg10 ;
  short arg11 ;
  int arg12 ;
  vrna_param_t *arg13 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  short val8 ;
  int ecode8 = 0 ;
  short val9 ;
  int ecode9 = 0 ;
  short val10 ;
  int ecode10 = 0 ;
  short val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"type_2",  (char *)"i",  (char *)"j",  (char *)"p",  (char *)"q",  (char *)"cutpoint",  (char *)"si1",  (char *)"sj1",  (char *)"sp1",  (char *)"sq1",  (char *)"dangles",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOO:__E_IntLoop_Co", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "__E_IntLoop_Co" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "__E_IntLoop_Co" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__E_IntLoop_Co" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "__E_IntLoop_Co" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "__E_IntLoop_Co" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "__E_IntLoop_Co" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "__E_IntLoop_Co" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_short(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "__E_IntLoop_Co" "', argument " "8"" of type '" "short""'");
  } 
  arg8 = static_cast< short >(val8);
  ecode9 = SWIG_AsVal_short(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "__E_IntLoop_Co" "', argument " "9"" of type '" "short""'");
  } 
  arg9 = static_cast< short >(val9);
  ecode10 = SWIG_AsVal_short(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "__E_IntLoop_Co" "', argument " "10"" of type '" "short""'");
  } 
  arg10 = static_cast< short >(val10);
  ecode11 = SWIG_AsVal_short(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "__E_IntLoop_Co" "', argument " "11"" of type '" "short""'");
  } 
  arg11 = static_cast< short >(val11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "__E_IntLoop_Co" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "__E_IntLoop_Co" "', argument " "13"" of type '" "vrna_param_t *""'"); 
  }
  arg13 = reinterpret_cast< vrna_param_t * >(argp13);
  {
    try {
      result = (int)__E_IntLoop_Co(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ubf_eval_int_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  short arg9 ;
  short arg10 ;
  short arg11 ;
  short arg12 ;
  unsigned char arg13 ;
  unsigned char arg14 ;
  int *arg15 = 0 ;
  int arg16 ;
  int arg17 ;
  vrna_param_t *arg18 = 0 ;
  vrna_sc_t *arg19 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  short val9 ;
  int ecode9 = 0 ;
  short val10 ;
  int ecode10 = 0 ;
  short val11 ;
  int ecode11 = 0 ;
  short val12 ;
  int ecode12 = 0 ;
  unsigned char val13 ;
  int ecode13 = 0 ;
  unsigned char val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  (char *)"p",  (char *)"q",  (char *)"i1",  (char *)"j1",  (char *)"p1",  (char *)"q1",  (char *)"si",  (char *)"sj",  (char *)"sp",  (char *)"sq",  (char *)"type",  (char *)"type_2",  (char *)"rtype",  (char *)"ij",  (char *)"cp",  (char *)"P",  (char *)"sc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOOOOOOOO:ubf_eval_int_loop", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17, &obj18)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ubf_eval_int_loop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubf_eval_int_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubf_eval_int_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ubf_eval_int_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ubf_eval_int_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ubf_eval_int_loop" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ubf_eval_int_loop" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ubf_eval_int_loop" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_short(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ubf_eval_int_loop" "', argument " "9"" of type '" "short""'");
  } 
  arg9 = static_cast< short >(val9);
  ecode10 = SWIG_AsVal_short(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ubf_eval_int_loop" "', argument " "10"" of type '" "short""'");
  } 
  arg10 = static_cast< short >(val10);
  ecode11 = SWIG_AsVal_short(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ubf_eval_int_loop" "', argument " "11"" of type '" "short""'");
  } 
  arg11 = static_cast< short >(val11);
  ecode12 = SWIG_AsVal_short(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ubf_eval_int_loop" "', argument " "12"" of type '" "short""'");
  } 
  arg12 = static_cast< short >(val12);
  ecode13 = SWIG_AsVal_unsigned_SS_char(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ubf_eval_int_loop" "', argument " "13"" of type '" "unsigned char""'");
  } 
  arg13 = static_cast< unsigned char >(val13);
  ecode14 = SWIG_AsVal_unsigned_SS_char(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ubf_eval_int_loop" "', argument " "14"" of type '" "unsigned char""'");
  } 
  arg14 = static_cast< unsigned char >(val14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ubf_eval_int_loop" "', argument " "15"" of type '" "int *""'"); 
  }
  arg15 = reinterpret_cast< int * >(argp15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ubf_eval_int_loop" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  ecode17 = SWIG_AsVal_int(obj16, &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "ubf_eval_int_loop" "', argument " "17"" of type '" "int""'");
  } 
  arg17 = static_cast< int >(val17);
  res18 = SWIG_ConvertPtr(obj17, &argp18,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "ubf_eval_int_loop" "', argument " "18"" of type '" "vrna_param_t *""'"); 
  }
  arg18 = reinterpret_cast< vrna_param_t * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19,SWIGTYPE_p_vrna_sc_s, 0 |  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "ubf_eval_int_loop" "', argument " "19"" of type '" "vrna_sc_t *""'"); 
  }
  arg19 = reinterpret_cast< vrna_sc_t * >(argp19);
  {
    try {
      result = (int)ubf_eval_int_loop(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ubf_eval_int_loop2(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  short arg9 ;
  short arg10 ;
  short arg11 ;
  short arg12 ;
  unsigned char arg13 ;
  unsigned char arg14 ;
  int *arg15 = 0 ;
  int arg16 ;
  unsigned int *arg17 = 0 ;
  unsigned int *arg18 = 0 ;
  vrna_param_t *arg19 = 0 ;
  vrna_sc_t *arg20 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  short val9 ;
  int ecode9 = 0 ;
  short val10 ;
  int ecode10 = 0 ;
  short val11 ;
  int ecode11 = 0 ;
  short val12 ;
  int ecode12 = 0 ;
  unsigned char val13 ;
  int ecode13 = 0 ;
  unsigned char val14 ;
  int ecode14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  void *argp18 = 0 ;
  int res18 = 0 ;
  void *argp19 = 0 ;
  int res19 = 0 ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  PyObject * obj17 = 0 ;
  PyObject * obj18 = 0 ;
  PyObject * obj19 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  (char *)"p",  (char *)"q",  (char *)"i1",  (char *)"j1",  (char *)"p1",  (char *)"q1",  (char *)"si",  (char *)"sj",  (char *)"sp",  (char *)"sq",  (char *)"type",  (char *)"type_2",  (char *)"rtype",  (char *)"ij",  (char *)"sn",  (char *)"ss",  (char *)"P",  (char *)"sc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOOOOOOOOO:ubf_eval_int_loop2", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16, &obj17, &obj18, &obj19)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ubf_eval_int_loop2" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubf_eval_int_loop2" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubf_eval_int_loop2" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ubf_eval_int_loop2" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ubf_eval_int_loop2" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ubf_eval_int_loop2" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ubf_eval_int_loop2" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ubf_eval_int_loop2" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_short(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ubf_eval_int_loop2" "', argument " "9"" of type '" "short""'");
  } 
  arg9 = static_cast< short >(val9);
  ecode10 = SWIG_AsVal_short(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ubf_eval_int_loop2" "', argument " "10"" of type '" "short""'");
  } 
  arg10 = static_cast< short >(val10);
  ecode11 = SWIG_AsVal_short(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ubf_eval_int_loop2" "', argument " "11"" of type '" "short""'");
  } 
  arg11 = static_cast< short >(val11);
  ecode12 = SWIG_AsVal_short(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ubf_eval_int_loop2" "', argument " "12"" of type '" "short""'");
  } 
  arg12 = static_cast< short >(val12);
  ecode13 = SWIG_AsVal_unsigned_SS_char(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ubf_eval_int_loop2" "', argument " "13"" of type '" "unsigned char""'");
  } 
  arg13 = static_cast< unsigned char >(val13);
  ecode14 = SWIG_AsVal_unsigned_SS_char(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ubf_eval_int_loop2" "', argument " "14"" of type '" "unsigned char""'");
  } 
  arg14 = static_cast< unsigned char >(val14);
  res15 = SWIG_ConvertPtr(obj14, &argp15,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "ubf_eval_int_loop2" "', argument " "15"" of type '" "int *""'"); 
  }
  arg15 = reinterpret_cast< int * >(argp15);
  ecode16 = SWIG_AsVal_int(obj15, &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "ubf_eval_int_loop2" "', argument " "16"" of type '" "int""'");
  } 
  arg16 = static_cast< int >(val16);
  res17 = SWIG_ConvertPtr(obj16, &argp17,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ubf_eval_int_loop2" "', argument " "17"" of type '" "unsigned int *""'"); 
  }
  arg17 = reinterpret_cast< unsigned int * >(argp17);
  res18 = SWIG_ConvertPtr(obj17, &argp18,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res18)) {
    SWIG_exception_fail(SWIG_ArgError(res18), "in method '" "ubf_eval_int_loop2" "', argument " "18"" of type '" "unsigned int *""'"); 
  }
  arg18 = reinterpret_cast< unsigned int * >(argp18);
  res19 = SWIG_ConvertPtr(obj18, &argp19,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res19)) {
    SWIG_exception_fail(SWIG_ArgError(res19), "in method '" "ubf_eval_int_loop2" "', argument " "19"" of type '" "vrna_param_t *""'"); 
  }
  arg19 = reinterpret_cast< vrna_param_t * >(argp19);
  res20 = SWIG_ConvertPtr(obj19, &argp20,SWIGTYPE_p_vrna_sc_s, 0 |  0 );
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "ubf_eval_int_loop2" "', argument " "20"" of type '" "vrna_sc_t *""'"); 
  }
  arg20 = reinterpret_cast< vrna_sc_t * >(argp20);
  {
    try {
      result = (int)ubf_eval_int_loop2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ubf_eval_ext_int_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  short arg9 ;
  short arg10 ;
  short arg11 ;
  short arg12 ;
  unsigned char arg13 ;
  unsigned char arg14 ;
  int arg15 ;
  vrna_param_t *arg16 = 0 ;
  vrna_sc_t *arg17 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  short val9 ;
  int ecode9 = 0 ;
  short val10 ;
  int ecode10 = 0 ;
  short val11 ;
  int ecode11 = 0 ;
  short val12 ;
  int ecode12 = 0 ;
  unsigned char val13 ;
  int ecode13 = 0 ;
  unsigned char val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  void *argp16 = 0 ;
  int res16 = 0 ;
  void *argp17 = 0 ;
  int res17 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  PyObject * obj13 = 0 ;
  PyObject * obj14 = 0 ;
  PyObject * obj15 = 0 ;
  PyObject * obj16 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  (char *)"p",  (char *)"q",  (char *)"i1",  (char *)"j1",  (char *)"p1",  (char *)"q1",  (char *)"si",  (char *)"sj",  (char *)"sp",  (char *)"sq",  (char *)"type",  (char *)"type_2",  (char *)"length",  (char *)"P",  (char *)"sc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOOOOOO:ubf_eval_ext_int_loop", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12, &obj13, &obj14, &obj15, &obj16)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ubf_eval_ext_int_loop" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ubf_eval_ext_int_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ubf_eval_ext_int_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ubf_eval_ext_int_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ubf_eval_ext_int_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ubf_eval_ext_int_loop" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ubf_eval_ext_int_loop" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(obj7, &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ubf_eval_ext_int_loop" "', argument " "8"" of type '" "int""'");
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_short(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "ubf_eval_ext_int_loop" "', argument " "9"" of type '" "short""'");
  } 
  arg9 = static_cast< short >(val9);
  ecode10 = SWIG_AsVal_short(obj9, &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "ubf_eval_ext_int_loop" "', argument " "10"" of type '" "short""'");
  } 
  arg10 = static_cast< short >(val10);
  ecode11 = SWIG_AsVal_short(obj10, &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "ubf_eval_ext_int_loop" "', argument " "11"" of type '" "short""'");
  } 
  arg11 = static_cast< short >(val11);
  ecode12 = SWIG_AsVal_short(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ubf_eval_ext_int_loop" "', argument " "12"" of type '" "short""'");
  } 
  arg12 = static_cast< short >(val12);
  ecode13 = SWIG_AsVal_unsigned_SS_char(obj12, &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ubf_eval_ext_int_loop" "', argument " "13"" of type '" "unsigned char""'");
  } 
  arg13 = static_cast< unsigned char >(val13);
  ecode14 = SWIG_AsVal_unsigned_SS_char(obj13, &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ubf_eval_ext_int_loop" "', argument " "14"" of type '" "unsigned char""'");
  } 
  arg14 = static_cast< unsigned char >(val14);
  ecode15 = SWIG_AsVal_int(obj14, &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "ubf_eval_ext_int_loop" "', argument " "15"" of type '" "int""'");
  } 
  arg15 = static_cast< int >(val15);
  res16 = SWIG_ConvertPtr(obj15, &argp16,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res16)) {
    SWIG_exception_fail(SWIG_ArgError(res16), "in method '" "ubf_eval_ext_int_loop" "', argument " "16"" of type '" "vrna_param_t *""'"); 
  }
  arg16 = reinterpret_cast< vrna_param_t * >(argp16);
  res17 = SWIG_ConvertPtr(obj16, &argp17,SWIGTYPE_p_vrna_sc_s, 0 |  0 );
  if (!SWIG_IsOK(res17)) {
    SWIG_exception_fail(SWIG_ArgError(res17), "in method '" "ubf_eval_ext_int_loop" "', argument " "17"" of type '" "vrna_sc_t *""'"); 
  }
  arg17 = reinterpret_cast< vrna_sc_t * >(argp17);
  {
    try {
      result = (int)ubf_eval_ext_int_loop(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_MLstem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  vrna_param_t *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:E_MLstem", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_MLstem" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_MLstem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "E_MLstem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "E_MLstem" "', argument " "4"" of type '" "vrna_param_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_param_t * >(argp4);
  {
    try {
      result = (int)E_MLstem(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_E_MLstem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  vrna_exp_param_t *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"type",  (char *)"si1",  (char *)"sj1",  (char *)"P",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:exp_E_MLstem", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "exp_E_MLstem" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "exp_E_MLstem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "exp_E_MLstem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "exp_E_MLstem" "', argument " "4"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_exp_param_t * >(argp4);
  {
    try {
      result = (FLT_OR_DBL)exp_E_MLstem(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_gquad(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int *arg2 = (int *)0 ;
  vrna_param_t *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"L",  (char *)"l",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:E_gquad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_gquad" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "E_gquad" "', argument " "2"" of type '" "int [3]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "E_gquad" "', argument " "3"" of type '" "vrna_param_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_param_t * >(argp3);
  {
    try {
      result = (int)E_gquad(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_E_gquad(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int *arg2 = (int *)0 ;
  vrna_exp_param_t *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"L",  (char *)"l",  (char *)"pf",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:exp_E_gquad", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "exp_E_gquad" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "exp_E_gquad" "', argument " "2"" of type '" "int [3]""'"); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "exp_E_gquad" "', argument " "3"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_exp_param_t * >(argp3);
  {
    try {
      result = (FLT_OR_DBL)exp_E_gquad(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_gquad_ali_en(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int *arg3 = (int *)0 ;
  short **arg4 = 0 ;
  unsigned int **arg5 = 0 ;
  unsigned int arg6 ;
  vrna_param_t *arg7 = 0 ;
  int *arg8 = (int *)0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"L",  (char *)"l",  (char *)"S",  (char *)"a2s",  (char *)"n_seq",  (char *)"P",  (char *)"en",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOO:E_gquad_ali_en", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_gquad_ali_en" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_gquad_ali_en" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "E_gquad_ali_en" "', argument " "3"" of type '" "int [3]""'"); 
  } 
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "E_gquad_ali_en" "', argument " "4"" of type '" "short const **""'"); 
  }
  arg4 = reinterpret_cast< short ** >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "E_gquad_ali_en" "', argument " "5"" of type '" "unsigned int **""'"); 
  }
  arg5 = reinterpret_cast< unsigned int ** >(argp5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "E_gquad_ali_en" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "E_gquad_ali_en" "', argument " "7"" of type '" "vrna_param_t *""'"); 
  }
  arg7 = reinterpret_cast< vrna_param_t * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "E_gquad_ali_en" "', argument " "8"" of type '" "int [2]""'"); 
  } 
  arg8 = reinterpret_cast< int * >(argp8);
  {
    try {
      E_gquad_ali_en(arg1,arg2,arg3,(short const **)arg4,arg5,arg6,arg7,arg8);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_exp_E_gquad_ali(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int *arg3 = (int *)0 ;
  short **arg4 = 0 ;
  unsigned int **arg5 = 0 ;
  int arg6 ;
  vrna_exp_param_t *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"L",  (char *)"l",  (char *)"S",  (char *)"a2s",  (char *)"n_seq",  (char *)"pf",  NULL 
  };
  FLT_OR_DBL result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:exp_E_gquad_ali", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "exp_E_gquad_ali" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "exp_E_gquad_ali" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "exp_E_gquad_ali" "', argument " "3"" of type '" "int [3]""'"); 
  } 
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "exp_E_gquad_ali" "', argument " "4"" of type '" "short **""'"); 
  }
  arg4 = reinterpret_cast< short ** >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "exp_E_gquad_ali" "', argument " "5"" of type '" "unsigned int **""'"); 
  }
  arg5 = reinterpret_cast< unsigned int ** >(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "exp_E_gquad_ali" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "exp_E_gquad_ali" "', argument " "7"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg7 = reinterpret_cast< vrna_exp_param_t * >(argp7);
  {
    try {
      result = (FLT_OR_DBL)exp_E_gquad_ali(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_maximum_matching(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:maximum_matching", kwnames, &obj0)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "maximum_matching" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)my_maximum_matching(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  float *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_fold(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_fold(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_fold__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_fold__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_fold(char *,float *)\n"
    "    my_fold(char *,char *,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_alifold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  float *arg2 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "alifold" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (char *)my_alifold(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_alifold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "alifold" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "alifold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_alifold(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_alifold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "alifold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_alifold__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_alifold__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'alifold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_alifold(std::vector< std::string,std::allocator< std::string > >,float *)\n"
    "    my_alifold(std::vector< std::string,std::allocator< std::string > >,char *,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_cofold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  float *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cofold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_cofold(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_cofold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "cofold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "cofold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_cofold(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_cofold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "cofold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_cofold__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_cofold__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'cofold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_cofold(char *,float *)\n"
    "    my_cofold(char *,char *,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_circfold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  float *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "circfold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_circfold(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_circfold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "circfold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "circfold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_circfold(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_circfold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "circfold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_circfold__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_circfold__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'circfold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_circfold(char *,float *)\n"
    "    my_circfold(char *,char *,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_circalifold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  float *arg2 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "circalifold" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (char *)my_circalifold(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_circalifold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "circalifold" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "circalifold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_circalifold(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_ml_rightmost_stem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  vrna_fold_compound_t *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  (char *)"fc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:E_ml_rightmost_stem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_ml_rightmost_stem" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_ml_rightmost_stem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "E_ml_rightmost_stem" "', argument " "3"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_fold_compound_t * >(argp3);
  {
    try {
      result = (int)E_ml_rightmost_stem(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_gquad_L_matrix(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int **arg5 = 0 ;
  vrna_param_t *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"S",  (char *)"start",  (char *)"maxdist",  (char *)"n",  (char *)"g",  (char *)"P",  NULL 
  };
  int **result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:get_gquad_L_matrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_gquad_L_matrix" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_gquad_L_matrix" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_gquad_L_matrix" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "get_gquad_L_matrix" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "get_gquad_L_matrix" "', argument " "5"" of type '" "int **""'"); 
  }
  arg5 = reinterpret_cast< int ** >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_gquad_L_matrix" "', argument " "6"" of type '" "vrna_param_t *""'"); 
  }
  arg6 = reinterpret_cast< vrna_param_t * >(argp6);
  {
    try {
      result = (int **)get_gquad_L_matrix(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_gquad_matrix(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  vrna_param_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"S",  (char *)"P",  NULL 
  };
  int *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:get_gquad_matrix", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_gquad_matrix" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_gquad_matrix" "', argument " "2"" of type '" "vrna_param_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_param_t * >(argp2);
  {
    try {
      result = (int *)get_gquad_matrix(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_gquad_ali_matrix(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  short *arg2 = 0 ;
  short **arg3 = 0 ;
  unsigned int **arg4 = 0 ;
  int arg5 ;
  vrna_param_t *arg6 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"n",  (char *)"S_cons",  (char *)"S",  (char *)"a2s",  (char *)"n_seq",  (char *)"P",  NULL 
  };
  int *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:get_gquad_ali_matrix", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_gquad_ali_matrix" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_gquad_ali_matrix" "', argument " "2"" of type '" "short *""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_gquad_ali_matrix" "', argument " "3"" of type '" "short **""'"); 
  }
  arg3 = reinterpret_cast< short ** >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_gquad_ali_matrix" "', argument " "4"" of type '" "unsigned int **""'"); 
  }
  arg4 = reinterpret_cast< unsigned int ** >(argp4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "get_gquad_ali_matrix" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_gquad_ali_matrix" "', argument " "6"" of type '" "vrna_param_t *""'"); 
  }
  arg6 = reinterpret_cast< vrna_param_t * >(argp6);
  {
    try {
      result = (int *)get_gquad_ali_matrix(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_GQuad_IntLoop_L_comparative(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  unsigned int *arg3 = 0 ;
  short *arg4 = 0 ;
  short **arg5 = 0 ;
  short **arg6 = 0 ;
  unsigned int **arg7 = 0 ;
  int **arg8 = 0 ;
  int arg9 ;
  vrna_param_t *arg10 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  (char *)"tt",  (char *)"S_cons",  (char *)"S5",  (char *)"S3",  (char *)"a2s",  (char *)"ggg",  (char *)"n_seq",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOO:E_GQuad_IntLoop_L_comparative", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "3"" of type '" "unsigned int *""'"); 
  }
  arg3 = reinterpret_cast< unsigned int * >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "4"" of type '" "short *""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "5"" of type '" "short **""'"); 
  }
  arg5 = reinterpret_cast< short ** >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "6"" of type '" "short **""'"); 
  }
  arg6 = reinterpret_cast< short ** >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "7"" of type '" "unsigned int **""'"); 
  }
  arg7 = reinterpret_cast< unsigned int ** >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "8"" of type '" "int **""'"); 
  }
  arg8 = reinterpret_cast< int ** >(argp8);
  ecode9 = SWIG_AsVal_int(obj8, &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "9"" of type '" "int""'");
  } 
  arg9 = static_cast< int >(val9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "E_GQuad_IntLoop_L_comparative" "', argument " "10"" of type '" "vrna_param_t *""'"); 
  }
  arg10 = reinterpret_cast< vrna_param_t * >(argp10);
  {
    try {
      result = (int)E_GQuad_IntLoop_L_comparative(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_E_GQuad_IntLoop_L(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  short *arg4 = 0 ;
  int **arg5 = 0 ;
  int arg6 ;
  vrna_param_t *arg7 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  (char *)"type",  (char *)"S",  (char *)"ggg",  (char *)"maxdist",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:E_GQuad_IntLoop_L", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "E_GQuad_IntLoop_L" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "E_GQuad_IntLoop_L" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "E_GQuad_IntLoop_L" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "E_GQuad_IntLoop_L" "', argument " "4"" of type '" "short *""'"); 
  }
  arg4 = reinterpret_cast< short * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "E_GQuad_IntLoop_L" "', argument " "5"" of type '" "int **""'"); 
  }
  arg5 = reinterpret_cast< int ** >(argp5);
  ecode6 = SWIG_AsVal_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "E_GQuad_IntLoop_L" "', argument " "6"" of type '" "int""'");
  } 
  arg6 = static_cast< int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "E_GQuad_IntLoop_L" "', argument " "7"" of type '" "vrna_param_t *""'"); 
  }
  arg7 = reinterpret_cast< vrna_param_t * >(argp7);
  {
    try {
      result = (int)E_GQuad_IntLoop_L(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_arrays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "free_arrays", 0, 0, 0)) SWIG_fail;
  {
    try {
      free_arrays();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_update_fold_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "update_fold_params", 0, 0, 0)) SWIG_fail;
  {
    try {
      update_fold_params();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_circalifold__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char **arg1 = 0 ;
  char *arg2 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    /* Check if is a list */
    if (PyList_Check(swig_obj[0])) {
      int size = PyList_Size(swig_obj[0]);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(swig_obj[0],i);
        if (PyUnicode_Check(o))
        arg1[i] = PyString_AsString(PyUnicode_AsASCIIString(o));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg1);
          return NULL;
        }
      }
      arg1[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "circalifold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (float)circalifold((char const **)arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  {
    free(arg1);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  {
    free(arg1);
  }
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_circalifold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "circalifold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_circalifold__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_p_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_circalifold__SWIG_2(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_circalifold__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'circalifold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_circalifold(std::vector< std::string,std::allocator< std::string > >,float *)\n"
    "    my_circalifold(std::vector< std::string,std::allocator< std::string > >,char *,float *)\n"
    "    circalifold(char const **,char *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_free_alifold_arrays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "free_alifold_arrays", 0, 0, 0)) SWIG_fail;
  {
    try {
      free_alifold_arrays();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_co_arrays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "free_co_arrays", 0, 0, 0)) SWIG_fail;
  {
    try {
      free_co_arrays();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_update_cofold_params(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "update_cofold_params", 0, 0, 0)) SWIG_fail;
  {
    try {
      update_cofold_params();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_initialize_cofold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"length",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:initialize_cofold", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "initialize_cofold" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      initialize_cofold(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lfoldz(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  double arg3 ;
  FILE *arg4 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"window_size",  (char *)"min_z",  (char *)"nullfile",  NULL 
  };
  float result;
  
  arg4 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:Lfoldz", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Lfoldz" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lfoldz" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Lfoldz" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  if (obj3) {
    if(obj3 == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = obj3;
      arg4 = obj_to_file(obj3, &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (float)my_Lfoldz(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "Lfoldz" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "Lfoldz" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lfold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  FILE *arg3 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *pyfile3 = NULL ;
  long start_position3 = -1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"window_size",  (char *)"nullfile",  NULL 
  };
  float result;
  
  arg3 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:Lfold", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "Lfold" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lfold" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    if(obj2 == Py_None){
      arg3 = NULL;
    } else {
      pyfile3 = obj2;
      arg3 = obj_to_file(obj2, &start_position3);
    }
  }
  /* pass, even if arg3 == NULL */
  {
    try {
      result = (float)my_Lfold(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "Lfold" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "Lfold" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliLfold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  int arg2 ;
  FILE *arg3 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *pyfile3 = NULL ;
  long start_position3 = -1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"window_size",  (char *)"nullfile",  NULL 
  };
  float result;
  
  arg3 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:aliLfold", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aliLfold" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliLfold" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    if(obj2 == Py_None){
      arg3 = NULL;
    } else {
      pyfile3 = obj2;
      arg3 = obj_to_file(obj2, &start_position3);
    }
  }
  /* pass, even if arg3 == NULL */
  {
    try {
      result = (float)my_aliLfold(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "aliLfold" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "aliLfold" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_backtrack_GQuad_IntLoop_L(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  short *arg5 = 0 ;
  int **arg6 = 0 ;
  int arg7 ;
  int *arg8 = 0 ;
  int *arg9 = 0 ;
  vrna_param_t *arg10 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  char * kwnames[] = {
    (char *)"c",  (char *)"i",  (char *)"j",  (char *)"type",  (char *)"S",  (char *)"ggg",  (char *)"maxdist",  (char *)"p",  (char *)"q",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOO:backtrack_GQuad_IntLoop_L", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "5"" of type '" "short *""'"); 
  }
  arg5 = reinterpret_cast< short * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "6"" of type '" "int **""'"); 
  }
  arg6 = reinterpret_cast< int ** >(argp6);
  ecode7 = SWIG_AsVal_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "7"" of type '" "int""'");
  } 
  arg7 = static_cast< int >(val7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "9"" of type '" "int *""'"); 
  }
  arg9 = reinterpret_cast< int * >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "backtrack_GQuad_IntLoop_L" "', argument " "10"" of type '" "vrna_param_t *""'"); 
  }
  arg10 = reinterpret_cast< vrna_param_t * >(argp10);
  {
    try {
      result = (int)backtrack_GQuad_IntLoop_L(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_backtrack_GQuad_IntLoop_L_comparative(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int arg3 ;
  unsigned int *arg4 = 0 ;
  short *arg5 = 0 ;
  short **arg6 = 0 ;
  short **arg7 = 0 ;
  unsigned int **arg8 = 0 ;
  int **arg9 = 0 ;
  int *arg10 = 0 ;
  int *arg11 = 0 ;
  int arg12 ;
  vrna_param_t *arg13 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  PyObject * obj9 = 0 ;
  PyObject * obj10 = 0 ;
  PyObject * obj11 = 0 ;
  PyObject * obj12 = 0 ;
  char * kwnames[] = {
    (char *)"c",  (char *)"i",  (char *)"j",  (char *)"type",  (char *)"S_cons",  (char *)"S5",  (char *)"S3",  (char *)"a2s",  (char *)"ggg",  (char *)"p",  (char *)"q",  (char *)"n_seq",  (char *)"P",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOOO:backtrack_GQuad_IntLoop_L_comparative", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8, &obj9, &obj10, &obj11, &obj12)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "4"" of type '" "unsigned int *""'"); 
  }
  arg4 = reinterpret_cast< unsigned int * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "5"" of type '" "short *""'"); 
  }
  arg5 = reinterpret_cast< short * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "6"" of type '" "short **""'"); 
  }
  arg6 = reinterpret_cast< short ** >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "7"" of type '" "short **""'"); 
  }
  arg7 = reinterpret_cast< short ** >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "8"" of type '" "unsigned int **""'"); 
  }
  arg8 = reinterpret_cast< unsigned int ** >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_p_int, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "9"" of type '" "int **""'"); 
  }
  arg9 = reinterpret_cast< int ** >(argp9);
  res10 = SWIG_ConvertPtr(obj9, &argp10,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "10"" of type '" "int *""'"); 
  }
  arg10 = reinterpret_cast< int * >(argp10);
  res11 = SWIG_ConvertPtr(obj10, &argp11,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "11"" of type '" "int *""'"); 
  }
  arg11 = reinterpret_cast< int * >(argp11);
  ecode12 = SWIG_AsVal_int(obj11, &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "12"" of type '" "int""'");
  } 
  arg12 = static_cast< int >(val12);
  res13 = SWIG_ConvertPtr(obj12, &argp13,SWIGTYPE_p_vrna_param_t, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "backtrack_GQuad_IntLoop_L_comparative" "', argument " "13"" of type '" "vrna_param_t *""'"); 
  }
  arg13 = reinterpret_cast< vrna_param_t * >(argp13);
  {
    try {
      result = (int)backtrack_GQuad_IntLoop_L_comparative(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pf_fold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  float *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pf_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_pf_fold(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_pf_fold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pf_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pf_fold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_pf_fold(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_pf_fold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "pf_fold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_pf_fold__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_pf_fold__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'pf_fold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_pf_fold(char *,float *)\n"
    "    my_pf_fold(char *,char *,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pf_circ_fold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pf_circ_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pf_circ_fold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_pf_circ_fold(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_pf_circ_fold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  float *arg2 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pf_circ_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_pf_circ_fold(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_pf_circ_fold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "pf_circ_fold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_pf_circ_fold__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_pf_circ_fold__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'pf_circ_fold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_pf_circ_fold(char *,char *,float *)\n"
    "    my_pf_circ_fold(char *,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_pf_add(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"dG1",  (char *)"dG2",  (char *)"kT",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:pf_add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pf_add" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pf_add" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_double(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pf_add" "', argument " "3"" of type '" "double""'");
    } 
    arg3 = static_cast< double >(val3);
  }
  {
    try {
      result = (double)my_pf_add(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pf_float_precision(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  int result;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "pf_float_precision", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (int)vrna_pf_float_precision();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_st_back_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""st_back""' of type '""int""'");
    }
    st_back = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_st_back_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(st_back));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_pbacktrack(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:pbacktrack", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pbacktrack" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)pbacktrack(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_pbacktrack5(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"length",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:pbacktrack5", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pbacktrack5" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pbacktrack5" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (char *)pbacktrack5(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_pbacktrack_circ(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:pbacktrack_circ", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pbacktrack_circ" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)pbacktrack_circ(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_pf_arrays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "free_pf_arrays", 0, 0, 0)) SWIG_fail;
  {
    try {
      free_pf_arrays();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_update_pf_params(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"length",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:update_pf_params", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "update_pf_params" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      update_pf_params(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mean_bp_distance(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"length",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:mean_bp_distance", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "mean_bp_distance" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (double)mean_bp_distance(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_init_pf_fold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"length",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:init_pf_fold", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "init_pf_fold" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      init_pf_fold(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_init_pf_circ_fold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"length",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:init_pf_circ_fold", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "init_pf_circ_fold" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      init_pf_circ_fold(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_centroid(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  double *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"length",  (char *)"dist",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:centroid", kwnames, &obj0, &obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "centroid" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "centroid" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  {
    try {
      result = (char *)centroid(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_co_pf_fold__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  float *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  float temp5 ;
  int res5 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "co_pf_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)my_co_pf_fold(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_co_pf_fold__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  float *arg5 = 0 ;
  float *arg6 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  float temp5 ;
  int res5 = SWIG_TMPOBJ ;
  float temp6 ;
  int res6 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "co_pf_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "co_pf_fold" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_co_pf_fold(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg6)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_co_pf_fold(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "co_pf_fold", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_co_pf_fold__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_co_pf_fold__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'co_pf_fold'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_co_pf_fold(char *,float *,float *,float *,float *)\n"
    "    my_co_pf_fold(char *,char *,float *,float *,float *,float *)\n");
  return 0;
}


SWIGINTERN int Swig_var_mirnatog_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""mirnatog""' of type '""int""'");
    }
    mirnatog = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_mirnatog_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(mirnatog));
  return pyobj;
}


SWIGINTERN int Swig_var_F_monomer_set(PyObject *_val) {
  {
    double *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_double,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""F_monomer""' of type '""double [2]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)2; ++ii) *(double *)&F_monomer[ii] = *((double *)inp + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""F_monomer""' of type '""double [2]""'");
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_F_monomer_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(F_monomer), SWIGTYPE_p_double,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_free_co_pf_arrays(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "free_co_pf_arrays", 0, 0, 0)) SWIG_fail;
  {
    try {
      free_co_pf_arrays();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_update_co_pf_params(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"length",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:update_co_pf_params", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "update_co_pf_params" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      update_co_pf_params(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_gquad_pattern_pf(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  vrna_exp_param_t *arg4 = 0 ;
  int *arg5 = 0 ;
  int *arg6 = (int *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"S",  (char *)"i",  (char *)"j",  (char *)"pf",  (char *)"L",  (char *)"l",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:get_gquad_pattern_pf", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_gquad_pattern_pf" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_gquad_pattern_pf" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_gquad_pattern_pf" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_gquad_pattern_pf" "', argument " "4"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_exp_param_t * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "get_gquad_pattern_pf" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_gquad_pattern_pf" "', argument " "6"" of type '" "int [3]""'"); 
  } 
  arg6 = reinterpret_cast< int * >(argp6);
  {
    try {
      get_gquad_pattern_pf(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_plist_gquad_from_pr(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  vrna_smx_csr_FLT_OR_DBL_t *arg4 = 0 ;
  FLT_OR_DBL *arg5 = 0 ;
  FLT_OR_DBL *arg6 = 0 ;
  vrna_exp_param_t *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"S",  (char *)"gi",  (char *)"gj",  (char *)"q_gq",  (char *)"probs",  (char *)"scale",  (char *)"pf",  NULL 
  };
  plist *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:get_plist_gquad_from_pr", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_plist_gquad_from_pr" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_plist_gquad_from_pr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_plist_gquad_from_pr" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_smx_csr_FLT_OR_DBL_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_plist_gquad_from_pr" "', argument " "4"" of type '" "vrna_smx_csr_FLT_OR_DBL_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_smx_csr_FLT_OR_DBL_t * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "get_plist_gquad_from_pr" "', argument " "5"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg5 = reinterpret_cast< FLT_OR_DBL * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_plist_gquad_from_pr" "', argument " "6"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg6 = reinterpret_cast< FLT_OR_DBL * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "get_plist_gquad_from_pr" "', argument " "7"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg7 = reinterpret_cast< vrna_exp_param_t * >(argp7);
  {
    try {
      result = (plist *)get_plist_gquad_from_pr(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_elem_prob_s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_plist_gquad_from_pr_max(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  vrna_smx_csr_FLT_OR_DBL_t *arg4 = 0 ;
  FLT_OR_DBL *arg5 = 0 ;
  FLT_OR_DBL *arg6 = 0 ;
  int *arg7 = 0 ;
  int *arg8 = (int *)0 ;
  vrna_exp_param_t *arg9 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  PyObject * obj7 = 0 ;
  PyObject * obj8 = 0 ;
  char * kwnames[] = {
    (char *)"S",  (char *)"gi",  (char *)"gj",  (char *)"q_gq",  (char *)"probs",  (char *)"scale",  (char *)"L",  (char *)"l",  (char *)"pf",  NULL 
  };
  plist *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOO:get_plist_gquad_from_pr_max", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6, &obj7, &obj8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_plist_gquad_from_pr_max" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_plist_gquad_from_pr_max" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_plist_gquad_from_pr_max" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_vrna_smx_csr_FLT_OR_DBL_s, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_plist_gquad_from_pr_max" "', argument " "4"" of type '" "vrna_smx_csr_FLT_OR_DBL_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_smx_csr_FLT_OR_DBL_t * >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "get_plist_gquad_from_pr_max" "', argument " "5"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg5 = reinterpret_cast< FLT_OR_DBL * >(argp5);
  res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "get_plist_gquad_from_pr_max" "', argument " "6"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg6 = reinterpret_cast< FLT_OR_DBL * >(argp6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "get_plist_gquad_from_pr_max" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = reinterpret_cast< int * >(argp7);
  res8 = SWIG_ConvertPtr(obj7, &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "get_plist_gquad_from_pr_max" "', argument " "8"" of type '" "int [3]""'"); 
  } 
  arg8 = reinterpret_cast< int * >(argp8);
  res9 = SWIG_ConvertPtr(obj8, &argp9,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "get_plist_gquad_from_pr_max" "', argument " "9"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg9 = reinterpret_cast< vrna_exp_param_t * >(argp9);
  {
    try {
      result = (plist *)get_plist_gquad_from_pr_max(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_elem_prob_s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_gquad_pf_matrix(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  short *arg1 = 0 ;
  FLT_OR_DBL *arg2 = 0 ;
  vrna_exp_param_t *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"S",  (char *)"scale",  (char *)"pf",  NULL 
  };
  FLT_OR_DBL *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:get_gquad_pf_matrix", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_gquad_pf_matrix" "', argument " "1"" of type '" "short *""'"); 
  }
  arg1 = reinterpret_cast< short * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_gquad_pf_matrix" "', argument " "2"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg2 = reinterpret_cast< FLT_OR_DBL * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_gquad_pf_matrix" "', argument " "3"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_exp_param_t * >(argp3);
  {
    try {
      result = (FLT_OR_DBL *)get_gquad_pf_matrix(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_gquad_pf_matrix_comparative(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  short *arg2 = 0 ;
  short **arg3 = 0 ;
  unsigned int **arg4 = 0 ;
  FLT_OR_DBL *arg5 = 0 ;
  unsigned int arg6 ;
  vrna_exp_param_t *arg7 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"n",  (char *)"S_cons",  (char *)"S",  (char *)"a2s",  (char *)"scale",  (char *)"n_seq",  (char *)"pf",  NULL 
  };
  FLT_OR_DBL *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:get_gquad_pf_matrix_comparative", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_gquad_pf_matrix_comparative" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_gquad_pf_matrix_comparative" "', argument " "2"" of type '" "short *""'"); 
  }
  arg2 = reinterpret_cast< short * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_gquad_pf_matrix_comparative" "', argument " "3"" of type '" "short **""'"); 
  }
  arg3 = reinterpret_cast< short ** >(argp3);
  res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "get_gquad_pf_matrix_comparative" "', argument " "4"" of type '" "unsigned int **""'"); 
  }
  arg4 = reinterpret_cast< unsigned int ** >(argp4);
  res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "get_gquad_pf_matrix_comparative" "', argument " "5"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg5 = reinterpret_cast< FLT_OR_DBL * >(argp5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "get_gquad_pf_matrix_comparative" "', argument " "6"" of type '" "unsigned int""'");
  } 
  arg6 = static_cast< unsigned int >(val6);
  res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "get_gquad_pf_matrix_comparative" "', argument " "7"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg7 = reinterpret_cast< vrna_exp_param_t * >(argp7);
  {
    try {
      result = (FLT_OR_DBL *)get_gquad_pf_matrix_comparative(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_pr(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"i",  (char *)"j",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:get_pr", kwnames, &obj0, &obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_pr" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_pr" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (double)get_pr(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_centroid_struct_pl(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  double *arg2 = 0 ;
  vrna_ep_t *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"length",  (char *)"dist",  (char *)"pl",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:get_centroid_struct_pl", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_centroid_struct_pl" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_centroid_struct_pl" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_ep_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_centroid_struct_pl" "', argument " "3"" of type '" "vrna_ep_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_ep_t * >(argp3);
  {
    try {
      result = (char *)get_centroid_struct_pl(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_centroid_struct_pr(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  double *arg2 = 0 ;
  FLT_OR_DBL *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"length",  (char *)"dist",  (char *)"pr",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:get_centroid_struct_pr", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_centroid_struct_pr" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "get_centroid_struct_pr" "', argument " "2"" of type '" "double *""'"); 
  }
  arg2 = reinterpret_cast< double * >(argp2);
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "get_centroid_struct_pr" "', argument " "3"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg3 = reinterpret_cast< FLT_OR_DBL * >(argp3);
  {
    try {
      result = (char *)get_centroid_struct_pr(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MEA_from_plist__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > arg1 ;
  std::string arg2 ;
  double arg3 ;
  vrna_md_t *arg4 = 0 ;
  float *arg5 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  float temp5 ;
  int res5 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg5 = &temp5;
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "1"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MEA_from_plist" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "MEA_from_plist" "', argument " "4"" of type '" "vrna_md_t *""'"); 
  }
  arg4 = reinterpret_cast< vrna_md_t * >(argp4);
  {
    try {
      result = (char *)my_MEA_from_plist(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_float, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MEA_from_plist__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > arg1 ;
  std::string arg2 ;
  vrna_md_t *arg3 = 0 ;
  float *arg4 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "1"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_vrna_md_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MEA_from_plist" "', argument " "3"" of type '" "vrna_md_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_md_t * >(argp3);
  {
    try {
      result = (char *)my_MEA_from_plist(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MEA_from_plist__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > arg1 ;
  std::string arg2 ;
  double arg3 ;
  float *arg4 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg4 = &temp4;
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "1"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MEA_from_plist" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = (char *)my_MEA_from_plist(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MEA_from_plist__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > arg1 ;
  std::string arg2 ;
  float *arg3 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  {
    std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *ptr = (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "1"" of type '" "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "MEA_from_plist" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (char *)my_MEA_from_plist(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_MEA_from_plist(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "MEA_from_plist", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MEA_from_plist__SWIG_3(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_vrna_md_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MEA_from_plist__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MEA_from_plist__SWIG_2(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_vrna_md_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MEA_from_plist__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'MEA_from_plist'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_MEA_from_plist(std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >,std::string,double,vrna_md_t *,float *)\n"
    "    my_MEA_from_plist(std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >,std::string,vrna_md_t *,float *)\n"
    "    my_MEA_from_plist(std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >,std::string,double,float *)\n"
    "    my_MEA_from_plist(std::vector< vrna_ep_t,std::allocator< vrna_ep_t > >,std::string,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_pbacktrack_mem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_pbacktrack_mem_t *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_pbacktrack_mem", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_pbacktrack_mem_t *)new_vrna_pbacktrack_mem_t();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_pbacktrack_mem_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_pbacktrack_mem(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_pbacktrack_mem_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_pbacktrack_mem_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pbacktrack_mem" "', argument " "1"" of type '" "vrna_pbacktrack_mem_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_pbacktrack_mem_t * >(argp1);
  {
    try {
      delete_vrna_pbacktrack_mem_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *pbacktrack_mem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_pbacktrack_mem_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *pbacktrack_mem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_pfl_fold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  double arg4 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"w",  (char *)"L",  (char *)"cutoff",  NULL 
  };
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:pfl_fold", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "pfl_fold" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pfl_fold" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pfl_fold" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pfl_fold" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  {
    try {
      result = my_pfl_fold(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pfl_fold_up(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"ulength",  (char *)"window_size",  (char *)"max_bp_span",  NULL 
  };
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:pfl_fold_up", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "pfl_fold_up" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pfl_fold_up" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pfl_fold_up" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pfl_fold_up" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = pfl_fold_up(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_subopt_sorted_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""subopt_sorted""' of type '""int""'");
    }
    subopt_sorted = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_subopt_sorted_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(subopt_sorted));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_SOLUTION_energy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SOLUTION *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SOLUTION_energy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_energy_set" "', argument " "1"" of type '" "SOLUTION *""'"); 
  }
  arg1 = reinterpret_cast< SOLUTION * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTION_energy_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->energy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTION_energy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SOLUTION *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_energy_get" "', argument " "1"" of type '" "SOLUTION *""'"); 
  }
  arg1 = reinterpret_cast< SOLUTION * >(argp1);
  result = (float) ((arg1)->energy);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTION_structure_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SOLUTION *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "SOLUTION_structure_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_structure_set" "', argument " "1"" of type '" "SOLUTION *""'"); 
  }
  arg1 = reinterpret_cast< SOLUTION * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SOLUTION_structure_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->structure;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->structure = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->structure = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTION_structure_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SOLUTION *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_structure_get" "', argument " "1"" of type '" "SOLUTION *""'"); 
  }
  arg1 = reinterpret_cast< SOLUTION * >(argp1);
  result = (char *) ((arg1)->structure);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTION_get(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  SOLUTION *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  SOLUTION *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SOLUTION_get", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_get" "', argument " "1"" of type '" "SOLUTION *""'"); 
  }
  arg1 = reinterpret_cast< SOLUTION * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SOLUTION_get" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (SOLUTION *)SOLUTION_get(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SOLUTION_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SOLUTION *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SOLUTION_size" "', argument " "1"" of type '" "SOLUTION *""'"); 
  }
  arg1 = reinterpret_cast< SOLUTION * >(argp1);
  {
    try {
      result = (int)SOLUTION_size(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SOLUTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SOLUTION *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SOLUTION, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SOLUTION" "', argument " "1"" of type '" "SOLUTION *""'"); 
  }
  arg1 = reinterpret_cast< SOLUTION * >(argp1);
  {
    try {
      delete_SOLUTION(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SOLUTION(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  SOLUTION *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_SOLUTION", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (SOLUTION *)new SOLUTION();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SOLUTION_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_SOLUTION, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SOLUTION_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_subopt_solution_energy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  subopt_solution *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "subopt_solution_energy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt_solution_energy_set" "', argument " "1"" of type '" "subopt_solution *""'"); 
  }
  arg1 = reinterpret_cast< subopt_solution * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "subopt_solution_energy_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->energy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_subopt_solution_energy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  subopt_solution *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt_solution_energy_get" "', argument " "1"" of type '" "subopt_solution *""'"); 
  }
  arg1 = reinterpret_cast< subopt_solution * >(argp1);
  result = (float) ((arg1)->energy);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_subopt_solution_structure_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  subopt_solution *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "subopt_solution_structure_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt_solution_structure_set" "', argument " "1"" of type '" "subopt_solution *""'"); 
  }
  arg1 = reinterpret_cast< subopt_solution * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "subopt_solution_structure_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "subopt_solution_structure_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->structure = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_subopt_solution_structure_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  subopt_solution *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt_solution_structure_get" "', argument " "1"" of type '" "subopt_solution *""'"); 
  }
  arg1 = reinterpret_cast< subopt_solution * >(argp1);
  result = (std::string *) & ((arg1)->structure);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_subopt_solution___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  subopt_solution *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt_solution___str__" "', argument " "1"" of type '" "subopt_solution *""'"); 
  }
  arg1 = reinterpret_cast< subopt_solution * >(argp1);
  {
    try {
      result = subopt_solution___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_subopt_solution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  subopt_solution *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_subopt_solution", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (subopt_solution *)new subopt_solution();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_subopt_solution, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_subopt_solution(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  subopt_solution *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_subopt_solution, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_subopt_solution" "', argument " "1"" of type '" "subopt_solution *""'"); 
  }
  arg1 = reinterpret_cast< subopt_solution * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *subopt_solution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_subopt_solution, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *subopt_solution_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_SuboptVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_iterator" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_subopt_solution_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___nonzero__" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_subopt_solution_Sg____nonzero__((std::vector< subopt_solution > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___bool__" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_subopt_solution_Sg____bool__((std::vector< subopt_solution > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___len__" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = std_vector_Sl_subopt_solution_Sg____len__((std::vector< subopt_solution > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::difference_type arg2 ;
  std::vector< subopt_solution >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< subopt_solution,std::allocator< subopt_solution > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SuboptVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___getslice__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector___getslice__" "', argument " "2"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SuboptVector___getslice__" "', argument " "3"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< subopt_solution >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< subopt_solution,std::allocator< subopt_solution > > *)std_vector_Sl_subopt_solution_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::difference_type arg2 ;
  std::vector< subopt_solution >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___setslice__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector___setslice__" "', argument " "2"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SuboptVector___setslice__" "', argument " "3"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< subopt_solution >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::difference_type arg2 ;
  std::vector< subopt_solution >::difference_type arg3 ;
  std::vector< subopt_solution,std::allocator< subopt_solution > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___setslice__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector___setslice__" "', argument " "2"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SuboptVector___setslice__" "', argument " "3"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< subopt_solution >::difference_type >(val3);
  {
    std::vector< subopt_solution,std::allocator< subopt_solution > > *ptr = (std::vector< subopt_solution,std::allocator< subopt_solution > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SuboptVector___setslice__" "', argument " "4"" of type '" "std::vector< subopt_solution,std::allocator< subopt_solution > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector___setslice__" "', argument " "4"" of type '" "std::vector< subopt_solution,std::allocator< subopt_solution > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< subopt_solution,std::allocator< subopt_solution > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SuboptVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SuboptVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SuboptVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SuboptVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::__setslice__(std::vector< subopt_solution >::difference_type,std::vector< subopt_solution >::difference_type)\n"
    "    std::vector< subopt_solution >::__setslice__(std::vector< subopt_solution >::difference_type,std::vector< subopt_solution >::difference_type,std::vector< subopt_solution,std::allocator< subopt_solution > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuboptVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::difference_type arg2 ;
  std::vector< subopt_solution >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SuboptVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___delslice__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector___delslice__" "', argument " "2"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SuboptVector___delslice__" "', argument " "3"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< subopt_solution >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___delitem__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector___delitem__" "', argument " "2"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< subopt_solution,std::allocator< subopt_solution > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___getitem__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< subopt_solution,std::allocator< subopt_solution > > *)std_vector_Sl_subopt_solution_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< subopt_solution,std::allocator< subopt_solution > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___setitem__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< subopt_solution,std::allocator< subopt_solution > > *ptr = (std::vector< subopt_solution,std::allocator< subopt_solution > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SuboptVector___setitem__" "', argument " "3"" of type '" "std::vector< subopt_solution,std::allocator< subopt_solution > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector___setitem__" "', argument " "3"" of type '" "std::vector< subopt_solution,std::allocator< subopt_solution > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< subopt_solution,std::allocator< subopt_solution > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___setitem__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___delitem__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SuboptVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SuboptVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SuboptVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SuboptVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::__delitem__(std::vector< subopt_solution >::difference_type)\n"
    "    std::vector< subopt_solution >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuboptVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< subopt_solution >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___getitem__" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector___getitem__" "', argument " "2"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< subopt_solution >::value_type *) &std_vector_Sl_subopt_solution_Sg____getitem____SWIG_1((std::vector< subopt_solution > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< subopt_solution >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SuboptVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SuboptVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SuboptVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SuboptVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< subopt_solution >::__getitem__(std::vector< subopt_solution >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuboptVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::difference_type arg2 ;
  std::vector< subopt_solution >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector___setitem__" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector___setitem__" "', argument " "2"" of type '" "std::vector< subopt_solution >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SuboptVector___setitem__" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector___setitem__" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_subopt_solution_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(subopt_solution const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SuboptVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_SuboptVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SuboptVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_subopt_solution, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SuboptVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SuboptVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< subopt_solution,std::allocator< subopt_solution > > const &)\n"
    "    std::vector< subopt_solution >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< subopt_solution >::__setitem__(std::vector< subopt_solution >::difference_type,std::vector< subopt_solution >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuboptVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_pop" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_subopt_solution_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< subopt_solution >::value_type(result)), SWIGTYPE_p_subopt_solution, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SuboptVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_append" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SuboptVector_append" "', argument " "2"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector_append" "', argument " "2"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_subopt_solution_Sg__append(arg1,(subopt_solution const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuboptVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< subopt_solution > *)new std::vector< subopt_solution >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuboptVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< subopt_solution > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< subopt_solution,std::allocator< subopt_solution > > *ptr = (std::vector< subopt_solution,std::allocator< subopt_solution > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SuboptVector" "', argument " "1"" of type '" "std::vector< subopt_solution > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SuboptVector" "', argument " "1"" of type '" "std::vector< subopt_solution > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< subopt_solution > *)new std::vector< subopt_solution >((std::vector< subopt_solution > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_empty" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (bool)((std::vector< subopt_solution > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_size" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = ((std::vector< subopt_solution > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SuboptVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_swap" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_subopt_solution_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SuboptVector_swap" "', argument " "2"" of type '" "std::vector< subopt_solution > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector_swap" "', argument " "2"" of type '" "std::vector< subopt_solution > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< subopt_solution > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_begin" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< subopt_solution >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_end" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< subopt_solution >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_rbegin" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< subopt_solution >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_rend" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< subopt_solution >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_clear" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< subopt_solution > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_get_allocator" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = ((std::vector< subopt_solution > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< subopt_solution >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_subopt_solution_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuboptVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< subopt_solution > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SuboptVector" "', argument " "1"" of type '" "std::vector< subopt_solution >::size_type""'");
  } 
  arg1 = static_cast< std::vector< subopt_solution >::size_type >(val1);
  {
    try {
      result = (std::vector< subopt_solution > *)new std::vector< subopt_solution >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_pop_back" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_resize" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector_resize" "', argument " "2"" of type '" "std::vector< subopt_solution >::size_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< subopt_solution >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_erase" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_erase" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_erase" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_subopt_solution_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< subopt_solution >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::iterator arg2 ;
  std::vector< subopt_solution >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< subopt_solution >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_erase" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_erase" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_erase" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_erase" "', argument " "3"" of type '" "std::vector< subopt_solution >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_erase" "', argument " "3"" of type '" "std::vector< subopt_solution >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_subopt_solution_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< subopt_solution >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SuboptVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_SuboptVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_SuboptVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SuboptVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::erase(std::vector< subopt_solution >::iterator)\n"
    "    std::vector< subopt_solution >::erase(std::vector< subopt_solution >::iterator,std::vector< subopt_solution >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_SuboptVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution >::size_type arg1 ;
  std::vector< subopt_solution >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< subopt_solution > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SuboptVector" "', argument " "1"" of type '" "std::vector< subopt_solution >::size_type""'");
  } 
  arg1 = static_cast< std::vector< subopt_solution >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_SuboptVector" "', argument " "2"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_SuboptVector" "', argument " "2"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp2);
  {
    try {
      result = (std::vector< subopt_solution > *)new std::vector< subopt_solution >(SWIG_STD_MOVE(arg1),(std::vector< subopt_solution >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_SuboptVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_SuboptVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_SuboptVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_SuboptVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SuboptVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_subopt_solution, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_SuboptVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_SuboptVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::vector()\n"
    "    std::vector< subopt_solution >::vector(std::vector< subopt_solution > const &)\n"
    "    std::vector< subopt_solution >::vector(std::vector< subopt_solution >::size_type)\n"
    "    std::vector< subopt_solution >::vector(std::vector< subopt_solution >::size_type,std::vector< subopt_solution >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuboptVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SuboptVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_push_back" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SuboptVector_push_back" "', argument " "2"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector_push_back" "', argument " "2"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< subopt_solution >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_front" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (std::vector< subopt_solution >::value_type *) &((std::vector< subopt_solution > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< subopt_solution >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_back" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = (std::vector< subopt_solution >::value_type *) &((std::vector< subopt_solution > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_subopt_solution, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< subopt_solution >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::size_type arg2 ;
  std::vector< subopt_solution >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:SuboptVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_assign" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector_assign" "', argument " "2"" of type '" "std::vector< subopt_solution >::size_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SuboptVector_assign" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector_assign" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< subopt_solution >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::size_type arg2 ;
  std::vector< subopt_solution >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_resize" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector_resize" "', argument " "2"" of type '" "std::vector< subopt_solution >::size_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SuboptVector_resize" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector_resize" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< subopt_solution >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SuboptVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SuboptVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_subopt_solution, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SuboptVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SuboptVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::resize(std::vector< subopt_solution >::size_type)\n"
    "    std::vector< subopt_solution >::resize(std::vector< subopt_solution >::size_type,std::vector< subopt_solution >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuboptVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::iterator arg2 ;
  std::vector< subopt_solution >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< subopt_solution >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_insert" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_insert" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_insert" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "SuboptVector_insert" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector_insert" "', argument " "3"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_subopt_solution_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(subopt_solution const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< subopt_solution >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::iterator arg2 ;
  std::vector< subopt_solution >::size_type arg3 ;
  std::vector< subopt_solution >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_insert" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_insert" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "SuboptVector_insert" "', argument " "2"" of type '" "std::vector< subopt_solution >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SuboptVector_insert" "', argument " "3"" of type '" "std::vector< subopt_solution >::size_type""'");
  } 
  arg3 = static_cast< std::vector< subopt_solution >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_subopt_solution,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "SuboptVector_insert" "', argument " "4"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "SuboptVector_insert" "', argument " "4"" of type '" "std::vector< subopt_solution >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< subopt_solution >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_subopt_solution_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(subopt_solution const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "SuboptVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_subopt_solution, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SuboptVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< subopt_solution,std::allocator< subopt_solution > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< subopt_solution >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_subopt_solution, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SuboptVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'SuboptVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< subopt_solution >::insert(std::vector< subopt_solution >::iterator,std::vector< subopt_solution >::value_type const &)\n"
    "    std::vector< subopt_solution >::insert(std::vector< subopt_solution >::iterator,std::vector< subopt_solution >::size_type,std::vector< subopt_solution >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_SuboptVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  std::vector< subopt_solution >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:SuboptVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_reserve" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SuboptVector_reserve" "', argument " "2"" of type '" "std::vector< subopt_solution >::size_type""'");
  } 
  arg2 = static_cast< std::vector< subopt_solution >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_SuboptVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SuboptVector_capacity" "', argument " "1"" of type '" "std::vector< subopt_solution > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      result = ((std::vector< subopt_solution > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_SuboptVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< subopt_solution > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SuboptVector" "', argument " "1"" of type '" "std::vector< subopt_solution > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< subopt_solution > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *SuboptVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_subopt_solution_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *SuboptVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_subopt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  FILE *arg4 = NULL ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  SOLUTION *result = 0 ;
  
  arg4 = NULL;
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "subopt" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "subopt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (swig_obj[3]) {
    if(swig_obj[3] == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = swig_obj[3];
      arg4 = obj_to_file(swig_obj[3], &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = (SOLUTION *)my_subopt(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "subopt" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "subopt" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subopt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  FILE *arg3 = NULL ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *pyfile3 = NULL ;
  long start_position3 = -1 ;
  std::vector< subopt_solution,std::allocator< subopt_solution > > result;
  
  arg3 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "subopt" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "subopt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (swig_obj[2]) {
    if(swig_obj[2] == Py_None){
      arg3 = NULL;
    } else {
      pyfile3 = swig_obj[2];
      arg3 = obj_to_file(swig_obj[2], &start_position3);
    }
  }
  /* pass, even if arg3 == NULL */
  {
    try {
      result = my_subopt(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< subopt_solution,std::allocator< subopt_solution > > >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "subopt" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "subopt" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subopt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "subopt", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_subopt__SWIG_1(self, argc, argv);
        }
        int fd;
        if ((argv[2] == Py_None) ||
          (!PyLong_Check(argv[2]) &&                                /* is not an integer */
            PyObject_HasAttrString(argv[2], "fileno") &&             /* has fileno method */
            (PyObject_CallMethod(argv[2], "flush", NULL) != NULL) && /* flush() succeeded */
            ((fd = PyObject_AsFileDescriptor(argv[2])) != -1)        /* got file descriptor */
            )) {
          _v = 1;
        } else {
          _v = 0;
        }
        if (_v) {
          return _wrap_subopt__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_subopt__SWIG_0(self, argc, argv);
          }
          int fd;
          if ((argv[3] == Py_None) ||
            (!PyLong_Check(argv[3]) &&                                /* is not an integer */
              PyObject_HasAttrString(argv[3], "fileno") &&             /* has fileno method */
              (PyObject_CallMethod(argv[3], "flush", NULL) != NULL) && /* flush() succeeded */
              ((fd = PyObject_AsFileDescriptor(argv[3])) != -1)        /* got file descriptor */
              )) {
            _v = 1;
          } else {
            _v = 0;
          }
          if (_v) {
            return _wrap_subopt__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'subopt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_subopt(char *,char *,int,FILE *)\n"
    "    my_subopt(char *,int,FILE *)\n");
  return 0;
}


SWIGINTERN int Swig_var_print_energy_set(PyObject *_val) {
  {
    double val;
    int res = SWIG_AsVal_double(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""print_energy""' of type '""double""'");
    }
    print_energy = static_cast< double >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_print_energy_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_double(static_cast< double >(print_energy));
  return pyobj;
}


SWIGINTERN int Swig_var_density_of_states_set(PyObject *_val) {
  {
    int *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_int,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""density_of_states""' of type '""int [1000+1]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)1000+1; ++ii) *(int *)&density_of_states[ii] = *((int *)inp + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""density_of_states""' of type '""int [1000+1]""'");
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_density_of_states_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(density_of_states), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN PyObject *_wrap_zukersubopt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"string",  NULL 
  };
  SOLUTION *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:zukersubopt", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "zukersubopt" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (SOLUTION *)zukersubopt((char const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_SOLUTION, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_inverse_fold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"start",  (char *)"target",  NULL 
  };
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:inverse_fold", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inverse_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inverse_fold" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_inverse_fold(arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_inverse_pf_fold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  float *arg3 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"start",  (char *)"target",  NULL 
  };
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:inverse_pf_fold", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "inverse_pf_fold" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "inverse_pf_fold" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (char *)my_inverse_pf_fold(arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN int Swig_var_symbolset_set(PyObject *_val) {
  {
    free(symbolset);
    
    PyObject *bytes = NULL;
    const char *tmp = SWIG_PyUnicode_AsUTF8AndSize(_val, NULL, &bytes);
    Py_XDECREF(bytes);
    
    
    
    if ((tmp) &&
      (tmp[0])) {
      symbolset = strdup(tmp);
    } else {
      symbolset = (char *) vrna_alloc(sizeof(char) * 5);
      strncpy(symbolset, "AUGC", sizeof(char) * 5);
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_symbolset_get(void) {
  PyObject *pyobj = 0;
  
  {
    pyobj = SWIG_Python_str_FromChar((const char *)symbolset);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_final_cost_set(PyObject *_val) {
  {
    float val;
    int res = SWIG_AsVal_float(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""final_cost""' of type '""float""'");
    }
    final_cost = static_cast< float >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_final_cost_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_float(static_cast< float >(final_cost));
  return pyobj;
}


SWIGINTERN int Swig_var_give_up_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""give_up""' of type '""int""'");
    }
    give_up = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_give_up_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(give_up));
  return pyobj;
}


SWIGINTERN int Swig_var_inv_verbose_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""inv_verbose""' of type '""int""'");
    }
    inv_verbose = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_inv_verbose_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(inv_verbose));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_b2HIT(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2HIT", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "b2HIT" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)b2HIT(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_b2C(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2C", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "b2C" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)b2C(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_b2Shapiro(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Shapiro", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "b2Shapiro" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)b2Shapiro(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_add_root(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"arg1",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:add_root", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_root" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)add_root(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_expand_Shapiro(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"coarse",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:expand_Shapiro", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "expand_Shapiro" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)expand_Shapiro(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_expand_Full(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:expand_Full", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "expand_Full" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)expand_Full(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_unexpand_Full(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"ffull",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:unexpand_Full", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unexpand_Full" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)unexpand_Full(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_unweight(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"wcoarse",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:unweight", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unweight" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (char *)unweight(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  free(result);
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_unexpand_aligned_F(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char **arg1 = (char **)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"align",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:unexpand_aligned_F", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unexpand_aligned_F" "', argument " "1"" of type '" "char *[2]""'"); 
  } 
  arg1 = reinterpret_cast< char ** >(argp1);
  {
    try {
      unexpand_aligned_F(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_parse_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"structure",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:parse_structure", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_structure" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      parse_structure(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN int Swig_var_loop_size_set(PyObject *_val) {
  {
    int *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_int,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""loop_size""' of type '""int [1000]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)1000; ++ii) *(int *)&loop_size[ii] = *((int *)inp + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""loop_size""' of type '""int [1000]""'");
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_loop_size_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(loop_size), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_helix_size_set(PyObject *_val) {
  {
    int *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_int,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""helix_size""' of type '""int [1000]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)1000; ++ii) *(int *)&helix_size[ii] = *((int *)inp + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""helix_size""' of type '""int [1000]""'");
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_helix_size_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(helix_size), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_loop_degree_set(PyObject *_val) {
  {
    int *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_int,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""loop_degree""' of type '""int [1000]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)1000; ++ii) *(int *)&loop_degree[ii] = *((int *)inp + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""loop_degree""' of type '""int [1000]""'");
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_loop_degree_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(loop_degree), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_loops_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""loops""' of type '""int""'");
    }
    loops = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_loops_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(loops));
  return pyobj;
}


SWIGINTERN int Swig_var_unpaired_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""unpaired""' of type '""int""'");
    }
    unpaired = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_unpaired_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(unpaired));
  return pyobj;
}


SWIGINTERN int Swig_var_pairs_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""pairs""' of type '""int""'");
    }
    pairs = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_pairs_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(pairs));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_make_tree(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"struc",  NULL 
  };
  Tree *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:make_tree", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "make_tree" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (Tree *)make_tree(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Tree, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_tree_edit_distance(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Tree *arg1 = 0 ;
  Tree *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"T1",  (char *)"T2",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:tree_edit_distance", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "tree_edit_distance" "', argument " "1"" of type '" "Tree *""'"); 
  }
  arg1 = reinterpret_cast< Tree * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_Tree, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "tree_edit_distance" "', argument " "2"" of type '" "Tree *""'"); 
  }
  arg2 = reinterpret_cast< Tree * >(argp2);
  {
    try {
      result = (float)tree_edit_distance(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_tree(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Tree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"t",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:print_tree", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_tree" "', argument " "1"" of type '" "Tree *""'"); 
  }
  arg1 = reinterpret_cast< Tree * >(argp1);
  {
    try {
      print_tree(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_tree(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  Tree *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"t",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:free_tree", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_Tree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_tree" "', argument " "1"" of type '" "Tree *""'"); 
  }
  arg1 = reinterpret_cast< Tree * >(argp1);
  {
    try {
      free_tree(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Make_swString(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"string",  NULL 
  };
  swString *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Make_swString", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Make_swString" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  {
    try {
      result = (swString *)Make_swString(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swString, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_string_edit_distance(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  swString *arg1 = 0 ;
  swString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"T1",  (char *)"T2",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:string_edit_distance", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_swString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "string_edit_distance" "', argument " "1"" of type '" "swString *""'"); 
  }
  arg1 = reinterpret_cast< swString * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_swString, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "string_edit_distance" "', argument " "2"" of type '" "swString *""'"); 
  }
  arg2 = reinterpret_cast< swString * >(argp2);
  {
    try {
      result = (float)string_edit_distance(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_profile_edit_distance(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"T1",  (char *)"T2",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:profile_edit_distance", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "profile_edit_distance" "', argument " "1"" of type '" "float const *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "profile_edit_distance" "', argument " "2"" of type '" "float const *""'"); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  {
    try {
      result = (float)profile_edit_distance((float const *)arg1,(float const *)arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Make_bp_profile_bppm(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  FLT_OR_DBL *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"bppm",  (char *)"length",  NULL 
  };
  float *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:Make_bp_profile_bppm", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Make_bp_profile_bppm" "', argument " "1"" of type '" "FLT_OR_DBL *""'"); 
  }
  arg1 = reinterpret_cast< FLT_OR_DBL * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Make_bp_profile_bppm" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (float *)Make_bp_profile_bppm(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_print_bppm(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"T",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:print_bppm", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "print_bppm" "', argument " "1"" of type '" "float const *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  {
    try {
      print_bppm((float const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_profile(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  float *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"T",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:free_profile", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_profile" "', argument " "1"" of type '" "float *""'"); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  {
    try {
      free_profile(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Make_bp_profile(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"length",  NULL 
  };
  float *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:Make_bp_profile", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Make_bp_profile" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (float *)Make_bp_profile(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN int Swig_var_edit_backtrack_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""edit_backtrack""' of type '""int""'");
    }
    edit_backtrack = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_edit_backtrack_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(edit_backtrack));
  return pyobj;
}


SWIGINTERN int Swig_var_aligned_line_set(PyObject *_val) {
  {
    char * *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_p_char,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""aligned_line""' of type '""char *[2]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)2; ++ii) *(char * *)&aligned_line[ii] = *((char * *)inp + ii);
    } else {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in variable '""aligned_line""' of type '""char *[2]""'");
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_aligned_line_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(aligned_line), SWIGTYPE_p_p_char,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_cost_matrix_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""cost_matrix""' of type '""int""'");
    }
    cost_matrix = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_cost_matrix_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(cost_matrix));
  return pyobj;
}


SWIGINTERN PyObject *_wrap_deref_any(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  void **arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"ptr",  (char *)"index",  NULL 
  };
  void *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:deref_any", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "deref_any" "', argument " "1"" of type '" "void **""'"); 
  }
  arg1 = reinterpret_cast< void ** >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "deref_any" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    try {
      result = (void *)deref_any(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_aligned_line(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"arg1",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:get_aligned_line", kwnames, &obj0)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_aligned_line" "', argument " "1"" of type '" "int""'");
  } 
  arg1 = static_cast< int >(val1);
  {
    try {
      result = (char *)get_aligned_line(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_SHAPE_read(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  std::string *arg4 = 0 ;
  int *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  std::string temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"file_name",  (char *)"length",  (char *)"default_value",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:file_SHAPE_read", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "file_SHAPE_read" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "file_SHAPE_read" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "file_SHAPE_read" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    try {
      result = my_file_SHAPE_read((char const *)arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 0);
  }
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_fasta_read(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  FILE *arg4 = 0 ;
  unsigned int arg5 = 0 ;
  std::string temp1 ;
  int res1 = SWIG_TMPOBJ ;
  std::string temp2 ;
  int res2 = SWIG_TMPOBJ ;
  std::vector< std::string,std::allocator< std::string > > temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"file",  (char *)"options",  NULL 
  };
  int result;
  
  arg4 = NULL;
  arg1 = &temp1;
  arg2 = &temp2;
  arg3 = &temp3;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:file_fasta_read", kwnames, &obj0, &obj1)) SWIG_fail;
  if(obj0 == Py_None){
    arg4 = NULL;
  } else {
    pyfile4 = obj0;
    arg4 = obj_to_file(obj0, &start_position4);
  }
  if (obj1) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj1, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "file_fasta_read" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  if (arg4 == NULL) {
    /* The generated wrapper function raises TypeError on mismatching types. */
    SWIG_exception_fail(SWIG_TypeError, "in method '" "file_fasta_read" "', argument "
      "4"" of type '" "FILE *""'");
  }
  {
    try {
      result = (int)my_file_fasta_read(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg1)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_std__vectorT_std__string_t, new_flags), 0);
  }
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_fasta_read" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_fasta_read" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_RNAstrand_db_read_record(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  FILE *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  std::string *arg6 = 0 ;
  std::string *arg7 = 0 ;
  unsigned int arg8 = 0 ;
  PyObject *pyfile1 = NULL ;
  long start_position1 = -1 ;
  std::string temp2 ;
  int res2 = SWIG_TMPOBJ ;
  std::string temp3 ;
  int res3 = SWIG_TMPOBJ ;
  std::string temp4 ;
  int res4 = SWIG_TMPOBJ ;
  std::string temp5 ;
  int res5 = SWIG_TMPOBJ ;
  std::string temp6 ;
  int res6 = SWIG_TMPOBJ ;
  std::string temp7 ;
  int res7 = SWIG_TMPOBJ ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"fp",  (char *)"options",  NULL 
  };
  int result;
  
  arg1 = NULL;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:file_RNAstrand_db_read_record", kwnames, &obj0, &obj1)) SWIG_fail;
  if(obj0 == Py_None){
    arg1 = NULL;
  } else {
    pyfile1 = obj0;
    arg1 = obj_to_file(obj0, &start_position1);
  }
  if (obj1) {
    ecode8 = SWIG_AsVal_unsigned_SS_int(obj1, &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "file_RNAstrand_db_read_record" "', argument " "8"" of type '" "unsigned int""'");
    } 
    arg8 = static_cast< unsigned int >(val8);
  }
  if (arg1 == NULL) {
    /* The generated wrapper function raises TypeError on mismatching types. */
    SWIG_exception_fail(SWIG_TypeError, "in method '" "file_RNAstrand_db_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  {
    try {
      result = (int)my_file_RNAstrand_db_read_record(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg6)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg7)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_RNAstrand_db_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_RNAstrand_db_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_connect_read_record(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  FILE *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  unsigned int arg6 = 0 ;
  PyObject *pyfile1 = NULL ;
  long start_position1 = -1 ;
  std::string temp2 ;
  int res2 = SWIG_TMPOBJ ;
  std::string temp3 ;
  int res3 = SWIG_TMPOBJ ;
  std::string temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int res5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"fp",  (char *)"remainder",  (char *)"options",  NULL 
  };
  int result;
  
  arg1 = NULL;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:file_connect_read_record", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  if(obj0 == Py_None){
    arg1 = NULL;
  } else {
    pyfile1 = obj0;
    arg1 = obj_to_file(obj0, &start_position1);
  }
  res5 = SWIG_AsPtr_std_string(obj1, &arg5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "file_connect_read_record" "', argument " "5"" of type '" "std::string *""'");
  }
  res5 = SWIG_AddTmpMask(res5);
  if (obj2) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj2, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "file_connect_read_record" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  if (arg1 == NULL) {
    /* The generated wrapper function raises TypeError on mismatching types. */
    SWIG_exception_fail(SWIG_TypeError, "in method '" "file_connect_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  {
    try {
      result = (int)my_file_connect_read_record(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_connect_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return resultobj;
fail:
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_connect_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  if (SWIG_IsNewObj(res5)) delete arg5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_extract_record_rest_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char **arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"lines",  (char *)"length",  (char *)"option",  NULL 
  };
  char *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:extract_record_rest_structure", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  {
    /* Check if is a list */
    if (PyList_Check(obj0)) {
      int size = PyList_Size(obj0);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj0,i);
        if (PyUnicode_Check(o))
        arg1[i] = PyString_AsString(PyUnicode_AsASCIIString(o));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg1);
          return NULL;
        }
      }
      arg1[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "extract_record_rest_structure" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "extract_record_rest_structure" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (char *)extract_record_rest_structure((char const **)arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  {
    free(arg1);
  }
  return resultobj;
fail:
  {
    free(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_read_record(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char **arg1 = 0 ;
  char **arg2 = 0 ;
  char ***arg3 = 0 ;
  unsigned int arg4 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"header",  (char *)"sequence",  (char *)"rest",  (char *)"options",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:read_record", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    /* Check if is a list */
    if (PyList_Check(obj0)) {
      int size = PyList_Size(obj0);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj0,i);
        if (PyUnicode_Check(o))
        arg1[i] = PyString_AsString(PyUnicode_AsASCIIString(o));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg1);
          return NULL;
        }
      }
      arg1[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  {
    /* Check if is a list */
    if (PyList_Check(obj1)) {
      int size = PyList_Size(obj1);
      int i = 0;
      arg2 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj1,i);
        if (PyUnicode_Check(o))
        arg2[i] = PyString_AsString(PyUnicode_AsASCIIString(o));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg2);
          return NULL;
        }
      }
      arg2[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "read_record" "', argument " "3"" of type '" "char ***""'"); 
  }
  arg3 = reinterpret_cast< char *** >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "read_record" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    try {
      result = (unsigned int)read_record(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    free(arg1);
  }
  {
    free(arg2);
  }
  return resultobj;
fail:
  {
    free(arg1);
  }
  {
    free(arg2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_multi_input_line(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char **arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"options",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:get_multi_input_line", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    /* Check if is a list */
    if (PyList_Check(obj0)) {
      int size = PyList_Size(obj0);
      int i = 0;
      arg1 = (char **) malloc((size+1)*sizeof(char *));
      for (i = 0; i < size; i++) {
        PyObject *o = PyList_GetItem(obj0,i);
        if (PyUnicode_Check(o))
        arg1[i] = PyString_AsString(PyUnicode_AsASCIIString(o));
        else {
          PyErr_SetString(PyExc_TypeError,"list must contain strings");
          free(arg1);
          return NULL;
        }
      }
      arg1[i] = 0;
    } else {
      PyErr_SetString(PyExc_TypeError,"not a list");
      return NULL;
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_multi_input_line" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (unsigned int)get_multi_input_line(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    free(arg1);
  }
  return resultobj;
fail:
  {
    free(arg1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_msa_detect_format(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 = VRNA_FILE_FORMAT_MSA_DEFAULT ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"options",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:file_msa_detect_format", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_detect_format" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "file_msa_detect_format" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (unsigned int)my_file_msa_detect_format(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_msa_write(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  std::vector< std::string,std::allocator< std::string > > arg3 ;
  std::string arg4 = "" ;
  std::string arg5 = "" ;
  std::string arg6 = "" ;
  unsigned int arg7 = VRNA_FILE_FORMAT_MSA_STOCKHOLM|VRNA_FILE_FORMAT_MSA_APPEND ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"names",  (char *)"alignment",  (char *)"id",  (char *)"structure",  (char *)"source",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOOO:file_msa_write", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_write" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_write" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_write" "', argument " "3"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj3, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_write" "', argument " "4"" of type '" "std::string""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj4) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj4, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_write" "', argument " "5"" of type '" "std::string""'"); 
      }
      arg5 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj5) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj5, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_write" "', argument " "6"" of type '" "std::string""'"); 
      }
      arg6 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "file_msa_write" "', argument " "7"" of type '" "unsigned int""'");
    } 
    arg7 = static_cast< unsigned int >(val7);
  }
  {
    try {
      result = (int)my_file_msa_write(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_msa_read(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  unsigned int arg6 = VRNA_FILE_FORMAT_MSA_STOCKHOLM ;
  std::vector< std::string,std::allocator< std::string > > temp2 ;
  int res2 = SWIG_TMPOBJ ;
  std::vector< std::string,std::allocator< std::string > > temp3 ;
  int res3 = SWIG_TMPOBJ ;
  std::string temp4 ;
  int res4 = SWIG_TMPOBJ ;
  std::string temp5 ;
  int res5 = SWIG_TMPOBJ ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"options",  NULL 
  };
  int result;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:file_msa_read", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_msa_read" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj1, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "file_msa_read" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (int)my_file_msa_read(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_std__vectorT_std__string_t, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_std__vectorT_std__string_t, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_std__string, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_file_msa_read_record(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  FILE *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg2 = 0 ;
  std::vector< std::string,std::allocator< std::string > > *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  unsigned int arg6 = VRNA_FILE_FORMAT_MSA_STOCKHOLM ;
  PyObject *pyfile1 = NULL ;
  long start_position1 = -1 ;
  std::vector< std::string,std::allocator< std::string > > temp2 ;
  int res2 = SWIG_TMPOBJ ;
  std::vector< std::string,std::allocator< std::string > > temp3 ;
  int res3 = SWIG_TMPOBJ ;
  std::string temp4 ;
  int res4 = SWIG_TMPOBJ ;
  std::string temp5 ;
  int res5 = SWIG_TMPOBJ ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"filehandle",  (char *)"options",  NULL 
  };
  int result;
  
  arg1 = NULL;
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:file_msa_read_record", kwnames, &obj0, &obj1)) SWIG_fail;
  if(obj0 == Py_None){
    arg1 = NULL;
  } else {
    pyfile1 = obj0;
    arg1 = obj_to_file(obj0, &start_position1);
  }
  if (obj1) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj1, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "file_msa_read_record" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  if (arg1 == NULL) {
    /* The generated wrapper function raises TypeError on mismatching types. */
    SWIG_exception_fail(SWIG_TypeError, "in method '" "file_msa_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  {
    try {
      result = (int)my_file_msa_read_record(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_std__vectorT_std__string_t, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, swig::from((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_std__vectorT_std__string_t, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_std_string((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_std__string, new_flags), 0);
  }
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_msa_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg1, pyfile1, start_position1) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "file_msa_read_record" "', argument "
      "1"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_seq_encode(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  vrna_md_t *arg2 = NULL ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"md_p",  NULL 
  };
  std::vector< int,std::allocator< int > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:seq_encode", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "seq_encode" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "seq_encode" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      result = my_seq_encode(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< int,std::allocator< int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_cmd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_command_s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_cmd", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_command_s *)new_vrna_command_s();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_command_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_cmd(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_command_s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_command_s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_cmd" "', argument " "1"" of type '" "vrna_command_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_command_s * >(argp1);
  {
    try {
      delete_vrna_command_s(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *cmd_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_command_s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *cmd_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_file_commands_read(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  unsigned int arg2 = VRNA_CMD_PARSE_DEFAULTS ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"filename",  (char *)"options",  NULL 
  };
  vrna_command_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:file_commands_read", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "file_commands_read" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "file_commands_read" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (vrna_command_s *)my_file_commands_read(SWIG_STD_MOVE(arg1),arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_command_s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_enumerate_necklaces(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > arg1 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"entity_counts",  NULL 
  };
  std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:enumerate_necklaces", kwnames, &obj0)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "enumerate_necklaces" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_enumerate_necklaces(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotational_symmetry__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< unsigned int,std::allocator< unsigned int > > arg1 ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "rotational_symmetry" "', argument " "1"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_rotational_symmetry(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotational_symmetry__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "rotational_symmetry" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_rotational_symmetry(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotational_symmetry(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[2] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "rotational_symmetry", 0, 1, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_rotational_symmetry__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_rotational_symmetry__SWIG_0(self, argc, argv);
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'rotational_symmetry'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    my_rotational_symmetry(std::vector< unsigned int,std::allocator< unsigned int > >)\n"
    "    my_rotational_symmetry(std::string)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_boustrophedon__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "boustrophedon" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "boustrophedon" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = boustrophedon(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_boustrophedon__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "boustrophedon" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "boustrophedon" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "boustrophedon" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (unsigned int)boustrophedon(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_boustrophedon(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "boustrophedon", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_boustrophedon__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_boustrophedon__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'boustrophedon'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    boustrophedon(unsigned int,unsigned int)\n"
    "    boustrophedon(unsigned int,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_n_multichoose_k(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"n",  (char *)"k",  NULL 
  };
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:n_multichoose_k", kwnames, &obj0, &obj1)) SWIG_fail;
  ecode1 = SWIG_AsVal_unsigned_SS_int(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "n_multichoose_k" "', argument " "1"" of type '" "unsigned int""'");
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "n_multichoose_k" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = n_multichoose_k(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_i_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplex_list_t_i_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_i_set" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplex_list_t_i_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->i = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_i_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_i_get" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  result = (int) ((arg1)->i);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_j_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplex_list_t_j_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_j_set" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplex_list_t_j_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->j = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_j_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_j_get" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  result = (int) ((arg1)->j);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_energy_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplex_list_t_energy_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_energy_set" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "duplex_list_t_energy_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->energy = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_energy_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_energy_get" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  result = (double) ((arg1)->energy);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_structure_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "duplex_list_t_structure_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_structure_set" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "duplex_list_t_structure_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "duplex_list_t_structure_set" "', argument " "2"" of type '" "std::string const &""'"); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->structure = *arg2;
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res2)) delete arg2;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_list_t_structure_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "duplex_list_t_structure_get" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  result = (std::string *) & ((arg1)->structure);
  resultobj = SWIG_From_std_string(static_cast< std::string >(*result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_duplex_list_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_duplex_list_t", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (duplex_list_t *)new duplex_list_t();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_duplex_list_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_duplex_list_t(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  duplex_list_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_duplex_list_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_duplex_list_t" "', argument " "1"" of type '" "duplex_list_t *""'"); 
  }
  arg1 = reinterpret_cast< duplex_list_t * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *duplex_list_t_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_duplex_list_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *duplex_list_t_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_DuplexVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_iterator" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_duplex_list_t_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___nonzero__" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_duplex_list_t_Sg____nonzero__((std::vector< duplex_list_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___bool__" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_duplex_list_t_Sg____bool__((std::vector< duplex_list_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___len__" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = std_vector_Sl_duplex_list_t_Sg____len__((std::vector< duplex_list_t > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::difference_type arg2 ;
  std::vector< duplex_list_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< duplex_list_t,std::allocator< duplex_list_t > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DuplexVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___getslice__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector___getslice__" "', argument " "2"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DuplexVector___getslice__" "', argument " "3"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< duplex_list_t >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< duplex_list_t,std::allocator< duplex_list_t > > *)std_vector_Sl_duplex_list_t_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::difference_type arg2 ;
  std::vector< duplex_list_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___setslice__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector___setslice__" "', argument " "2"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DuplexVector___setslice__" "', argument " "3"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< duplex_list_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::difference_type arg2 ;
  std::vector< duplex_list_t >::difference_type arg3 ;
  std::vector< duplex_list_t,std::allocator< duplex_list_t > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___setslice__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector___setslice__" "', argument " "2"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DuplexVector___setslice__" "', argument " "3"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< duplex_list_t >::difference_type >(val3);
  {
    std::vector< duplex_list_t,std::allocator< duplex_list_t > > *ptr = (std::vector< duplex_list_t,std::allocator< duplex_list_t > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DuplexVector___setslice__" "', argument " "4"" of type '" "std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector___setslice__" "', argument " "4"" of type '" "std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DuplexVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DuplexVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DuplexVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DuplexVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::__setslice__(std::vector< duplex_list_t >::difference_type,std::vector< duplex_list_t >::difference_type)\n"
    "    std::vector< duplex_list_t >::__setslice__(std::vector< duplex_list_t >::difference_type,std::vector< duplex_list_t >::difference_type,std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DuplexVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::difference_type arg2 ;
  std::vector< duplex_list_t >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DuplexVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___delslice__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector___delslice__" "', argument " "2"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DuplexVector___delslice__" "', argument " "3"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< duplex_list_t >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___delitem__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector___delitem__" "', argument " "2"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< duplex_list_t,std::allocator< duplex_list_t > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___getitem__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< duplex_list_t,std::allocator< duplex_list_t > > *)std_vector_Sl_duplex_list_t_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< duplex_list_t,std::allocator< duplex_list_t > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___setitem__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< duplex_list_t,std::allocator< duplex_list_t > > *ptr = (std::vector< duplex_list_t,std::allocator< duplex_list_t > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DuplexVector___setitem__" "', argument " "3"" of type '" "std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector___setitem__" "', argument " "3"" of type '" "std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___setitem__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___delitem__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DuplexVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DuplexVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DuplexVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DuplexVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::__delitem__(std::vector< duplex_list_t >::difference_type)\n"
    "    std::vector< duplex_list_t >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DuplexVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< duplex_list_t >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___getitem__" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector___getitem__" "', argument " "2"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< duplex_list_t >::value_type *) &std_vector_Sl_duplex_list_t_Sg____getitem____SWIG_1((std::vector< duplex_list_t > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< duplex_list_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DuplexVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DuplexVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DuplexVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DuplexVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< duplex_list_t >::__getitem__(std::vector< duplex_list_t >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DuplexVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::difference_type arg2 ;
  std::vector< duplex_list_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector___setitem__" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector___setitem__" "', argument " "2"" of type '" "std::vector< duplex_list_t >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DuplexVector___setitem__" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector___setitem__" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_duplex_list_t_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(duplex_list_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DuplexVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_DuplexVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DuplexVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_duplex_list_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DuplexVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DuplexVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< duplex_list_t,std::allocator< duplex_list_t > > const &)\n"
    "    std::vector< duplex_list_t >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< duplex_list_t >::__setitem__(std::vector< duplex_list_t >::difference_type,std::vector< duplex_list_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DuplexVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_pop" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_duplex_list_t_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< duplex_list_t >::value_type(result)), SWIGTYPE_p_duplex_list_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DuplexVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_append" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DuplexVector_append" "', argument " "2"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector_append" "', argument " "2"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_duplex_list_t_Sg__append(arg1,(duplex_list_t const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplexVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< duplex_list_t > *)new std::vector< duplex_list_t >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplexVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< duplex_list_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< duplex_list_t,std::allocator< duplex_list_t > > *ptr = (std::vector< duplex_list_t,std::allocator< duplex_list_t > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DuplexVector" "', argument " "1"" of type '" "std::vector< duplex_list_t > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplexVector" "', argument " "1"" of type '" "std::vector< duplex_list_t > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< duplex_list_t > *)new std::vector< duplex_list_t >((std::vector< duplex_list_t > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_empty" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (bool)((std::vector< duplex_list_t > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_size" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = ((std::vector< duplex_list_t > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DuplexVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_swap" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_duplex_list_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DuplexVector_swap" "', argument " "2"" of type '" "std::vector< duplex_list_t > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector_swap" "', argument " "2"" of type '" "std::vector< duplex_list_t > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< duplex_list_t > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_begin" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< duplex_list_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_end" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< duplex_list_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_rbegin" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< duplex_list_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_rend" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< duplex_list_t >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_clear" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< duplex_list_t > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_get_allocator" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = ((std::vector< duplex_list_t > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< duplex_list_t >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_duplex_list_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplexVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< duplex_list_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DuplexVector" "', argument " "1"" of type '" "std::vector< duplex_list_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< duplex_list_t >::size_type >(val1);
  {
    try {
      result = (std::vector< duplex_list_t > *)new std::vector< duplex_list_t >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_pop_back" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_resize" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector_resize" "', argument " "2"" of type '" "std::vector< duplex_list_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< duplex_list_t >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_erase" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_erase" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_erase" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_duplex_list_t_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< duplex_list_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::iterator arg2 ;
  std::vector< duplex_list_t >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< duplex_list_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_erase" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_erase" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_erase" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_erase" "', argument " "3"" of type '" "std::vector< duplex_list_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_erase" "', argument " "3"" of type '" "std::vector< duplex_list_t >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_duplex_list_t_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< duplex_list_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DuplexVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_DuplexVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_DuplexVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DuplexVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::erase(std::vector< duplex_list_t >::iterator)\n"
    "    std::vector< duplex_list_t >::erase(std::vector< duplex_list_t >::iterator,std::vector< duplex_list_t >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_DuplexVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t >::size_type arg1 ;
  std::vector< duplex_list_t >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< duplex_list_t > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_DuplexVector" "', argument " "1"" of type '" "std::vector< duplex_list_t >::size_type""'");
  } 
  arg1 = static_cast< std::vector< duplex_list_t >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DuplexVector" "', argument " "2"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_DuplexVector" "', argument " "2"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp2);
  {
    try {
      result = (std::vector< duplex_list_t > *)new std::vector< duplex_list_t >(SWIG_STD_MOVE(arg1),(std::vector< duplex_list_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_DuplexVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_DuplexVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_DuplexVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_DuplexVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DuplexVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_duplex_list_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DuplexVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_DuplexVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::vector()\n"
    "    std::vector< duplex_list_t >::vector(std::vector< duplex_list_t > const &)\n"
    "    std::vector< duplex_list_t >::vector(std::vector< duplex_list_t >::size_type)\n"
    "    std::vector< duplex_list_t >::vector(std::vector< duplex_list_t >::size_type,std::vector< duplex_list_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DuplexVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DuplexVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_push_back" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DuplexVector_push_back" "', argument " "2"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector_push_back" "', argument " "2"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< duplex_list_t >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_front" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (std::vector< duplex_list_t >::value_type *) &((std::vector< duplex_list_t > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< duplex_list_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_back" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = (std::vector< duplex_list_t >::value_type *) &((std::vector< duplex_list_t > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_duplex_list_t, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< duplex_list_t >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::size_type arg2 ;
  std::vector< duplex_list_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:DuplexVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_assign" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector_assign" "', argument " "2"" of type '" "std::vector< duplex_list_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DuplexVector_assign" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector_assign" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< duplex_list_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::size_type arg2 ;
  std::vector< duplex_list_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_resize" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector_resize" "', argument " "2"" of type '" "std::vector< duplex_list_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DuplexVector_resize" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector_resize" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< duplex_list_t >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DuplexVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DuplexVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_duplex_list_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DuplexVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DuplexVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::resize(std::vector< duplex_list_t >::size_type)\n"
    "    std::vector< duplex_list_t >::resize(std::vector< duplex_list_t >::size_type,std::vector< duplex_list_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DuplexVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::iterator arg2 ;
  std::vector< duplex_list_t >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< duplex_list_t >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_insert" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_insert" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_insert" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DuplexVector_insert" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector_insert" "', argument " "3"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_duplex_list_t_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(duplex_list_t const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< duplex_list_t >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::iterator arg2 ;
  std::vector< duplex_list_t >::size_type arg3 ;
  std::vector< duplex_list_t >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_insert" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_insert" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "DuplexVector_insert" "', argument " "2"" of type '" "std::vector< duplex_list_t >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DuplexVector_insert" "', argument " "3"" of type '" "std::vector< duplex_list_t >::size_type""'");
  } 
  arg3 = static_cast< std::vector< duplex_list_t >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_duplex_list_t,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DuplexVector_insert" "', argument " "4"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "DuplexVector_insert" "', argument " "4"" of type '" "std::vector< duplex_list_t >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< duplex_list_t >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_duplex_list_t_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(duplex_list_t const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "DuplexVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_duplex_list_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DuplexVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< duplex_list_t,std::allocator< duplex_list_t > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< duplex_list_t >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_duplex_list_t, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DuplexVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'DuplexVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< duplex_list_t >::insert(std::vector< duplex_list_t >::iterator,std::vector< duplex_list_t >::value_type const &)\n"
    "    std::vector< duplex_list_t >::insert(std::vector< duplex_list_t >::iterator,std::vector< duplex_list_t >::size_type,std::vector< duplex_list_t >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_DuplexVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  std::vector< duplex_list_t >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:DuplexVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_reserve" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DuplexVector_reserve" "', argument " "2"" of type '" "std::vector< duplex_list_t >::size_type""'");
  } 
  arg2 = static_cast< std::vector< duplex_list_t >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_DuplexVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< duplex_list_t >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DuplexVector_capacity" "', argument " "1"" of type '" "std::vector< duplex_list_t > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      result = ((std::vector< duplex_list_t > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_DuplexVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< duplex_list_t > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DuplexVector" "', argument " "1"" of type '" "std::vector< duplex_list_t > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< duplex_list_t > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *DuplexVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_duplex_list_t_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *DuplexVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_duplexfold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"s1",  (char *)"s2",  NULL 
  };
  duplex_list_t result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:duplexfold", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "duplexfold" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "duplexfold" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_duplexfold(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new duplex_list_t(result)), SWIGTYPE_p_duplex_list_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_duplex_subopt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  int arg3 ;
  int arg4 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"s1",  (char *)"s2",  (char *)"delta",  (char *)"w",  NULL 
  };
  std::vector< duplex_list_t,std::allocator< duplex_list_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:duplex_subopt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "duplex_subopt" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "duplex_subopt" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "duplex_subopt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "duplex_subopt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = my_duplex_subopt(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< duplex_list_t,std::allocator< duplex_list_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliduplexfold(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"alignment1",  (char *)"alignment2",  NULL 
  };
  duplex_list_t result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:aliduplexfold", kwnames, &obj0, &obj1)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aliduplexfold" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aliduplexfold" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = my_aliduplexfold(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new duplex_list_t(result)), SWIGTYPE_p_duplex_list_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliduplex_subopt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  int arg3 ;
  int arg4 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"alignment1",  (char *)"alignment2",  (char *)"delta",  (char *)"w",  NULL 
  };
  std::vector< duplex_list_t,std::allocator< duplex_list_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:aliduplex_subopt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aliduplex_subopt" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aliduplex_subopt" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "aliduplex_subopt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "aliduplex_subopt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = my_aliduplex_subopt(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< duplex_list_t,std::allocator< duplex_list_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_concentrations(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  double arg7 ;
  double *arg8 = 0 ;
  double *arg9 = 0 ;
  double *arg10 = 0 ;
  double *arg11 = 0 ;
  double *arg12 = 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double temp8 ;
  int res8 = SWIG_TMPOBJ ;
  double temp9 ;
  int res9 = SWIG_TMPOBJ ;
  double temp10 ;
  int res10 = SWIG_TMPOBJ ;
  double temp11 ;
  int res11 = SWIG_TMPOBJ ;
  double temp12 ;
  int res12 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"FcAB",  (char *)"FcAA",  (char *)"FcBB",  (char *)"FEA",  (char *)"FEB",  (char *)"A0",  (char *)"BO",  NULL 
  };
  
  arg8 = &temp8;
  arg9 = &temp9;
  arg10 = &temp10;
  arg11 = &temp11;
  arg12 = &temp12;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:get_concentrations", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_concentrations" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_concentrations" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_concentrations" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "get_concentrations" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "get_concentrations" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  ecode6 = SWIG_AsVal_double(obj5, &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "get_concentrations" "', argument " "6"" of type '" "double""'");
  } 
  arg6 = static_cast< double >(val6);
  ecode7 = SWIG_AsVal_double(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "get_concentrations" "', argument " "7"" of type '" "double""'");
  } 
  arg7 = static_cast< double >(val7);
  {
    try {
      my_get_concentrations(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg9)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg10)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_double, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_double, new_flags), 1);
  }
  if (SWIG_IsTmpObj(res12)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg12)), 1);
  } else {
    int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_double, new_flags), 1);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_equilibrium_constants(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > arg3 ;
  double arg4 ;
  size_t arg5 = 0 ;
  size_t arg6 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"dG_complexes",  (char *)"dG_strands",  (char *)"A",  (char *)"kT",  (char *)"strands",  (char *)"complexes",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|OO:equilibrium_constants", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "equilibrium_constants" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "equilibrium_constants" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *ptr = (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "equilibrium_constants" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "equilibrium_constants" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  if (obj4) {
    ecode5 = SWIG_AsVal_size_t(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "equilibrium_constants" "', argument " "5"" of type '" "size_t""'");
    } 
    arg5 = static_cast< size_t >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_size_t(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "equilibrium_constants" "', argument " "6"" of type '" "size_t""'");
    } 
    arg6 = static_cast< size_t >(val6);
  }
  {
    try {
      result = my_equilibrium_constants(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_equilibrium_conc(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< double,std::allocator< double > > arg1 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > arg3 ;
  size_t arg4 = 0 ;
  size_t arg5 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"eq_constants",  (char *)"concentration_strands",  (char *)"A",  (char *)"strands",  (char *)"complexes",  NULL 
  };
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:equilibrium_conc", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "equilibrium_conc" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "equilibrium_conc" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *ptr = (std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "equilibrium_conc" "', argument " "3"" of type '" "std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_size_t(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "equilibrium_conc" "', argument " "4"" of type '" "size_t""'");
    } 
    arg4 = static_cast< size_t >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_size_t(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "equilibrium_conc" "', argument " "5"" of type '" "size_t""'");
    } 
    arg5 = static_cast< size_t >(val5);
  }
  {
    try {
      result = my_equilibrium_conc(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4),SWIG_STD_MOVE(arg5));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_pos_5_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "move_pos_5_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_pos_5_set" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "move_pos_5_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->pos_5 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_pos_5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_pos_5_get" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  result = (int) ((arg1)->pos_5);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_pos_3_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "move_pos_3_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_pos_3_set" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "move_pos_3_set" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->pos_3 = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_pos_3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_pos_3_get" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  result = (int) ((arg1)->pos_3);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_move(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 = 0 ;
  int arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"pos_5",  (char *)"pos_3",  NULL 
  };
  vrna_move_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:new_move", kwnames, &obj0, &obj1)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_int(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_move" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_move" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
  }
  {
    try {
      result = (vrna_move_t *)new_vrna_move_t(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_move_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_move(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_move" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  {
    try {
      delete_vrna_move_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_is_removal(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_is_removal" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  {
    try {
      result = (int)vrna_move_t_is_removal(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_is_insertion(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_is_insertion" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  {
    try {
      result = (int)vrna_move_t_is_insertion(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_is_shift(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_is_shift" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  {
    try {
      result = (int)vrna_move_t_is_shift(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move_compare(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  vrna_move_t *arg2 = 0 ;
  std::vector< int,std::allocator< int > > arg3 = (std::vector< int,std::allocator< int > >)std::vector< int >() ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"b",  (char *)"pt",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:move_compare", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move_compare" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "move_compare" "', argument " "2"" of type '" "vrna_move_t const *""'"); 
  }
  arg2 = reinterpret_cast< vrna_move_t * >(argp2);
  if (obj2) {
    {
      std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
      int res = swig::asptr(obj2, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "move_compare" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > > const""'"); 
      }
      arg3 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  {
    try {
      result = (int)vrna_move_t_compare(arg1,(vrna_move_t const *)arg2,SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_move___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_move_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "move___str__" "', argument " "1"" of type '" "vrna_move_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_move_t * >(argp1);
  {
    try {
      result = vrna_move_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *move_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_move_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *move_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_path_type_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "path_type_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_type_set" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "path_type_set" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->type = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_path_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_type_get" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  result = (unsigned int) ((arg1)->type);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_path_en_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "path_en_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_en_set" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "path_en_set" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (arg1) (arg1)->en = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_path_en_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_en_get" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  result = (double) ((arg1)->en);
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_path_s_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "path_s_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_s_set" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "path_s_set" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  delete[] arg1->s;
  if (arg2) {
    size_t size = strlen(reinterpret_cast< const char * >(arg2)) + 1;
    arg1->s = (char *)reinterpret_cast< char* >(memcpy(new char[size], reinterpret_cast< const char * >(arg2), sizeof(char)*(size)));
  } else {
    arg1->s = 0;
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_path_s_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_s_get" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  result = (char *) ((arg1)->s);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_path_move_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  vrna_move_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "path_move_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_move_set" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "path_move_set" "', argument " "2"" of type '" "vrna_move_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_move_t * >(argp2);
  if (arg1) (arg1)->move = *arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_path_move_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_move_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path_move_get" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  result = (vrna_move_t *)& ((arg1)->move);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_move_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_path(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  double arg1 ;
  std::string arg2 = "" ;
  vrna_move_t *arg3 = NULL ;
  unsigned int arg4 = VRNA_PATH_TYPE_DOT_BRACKET ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"en",  (char *)"s",  (char *)"move",  (char *)"type",  NULL 
  };
  vrna_path_t *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOO:new_path", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(obj0, &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_path" "', argument " "1"" of type '" "double""'");
  } 
  arg1 = static_cast< double >(val1);
  if (obj1) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj1, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_path" "', argument " "2"" of type '" "std::string""'"); 
      }
      arg2 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj2) {
    res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_vrna_move_t, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_path" "', argument " "3"" of type '" "vrna_move_t *""'"); 
    }
    arg3 = reinterpret_cast< vrna_move_t * >(argp3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_path" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (vrna_path_t *)new_vrna_path_t(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_path_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_path(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_path" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  {
    try {
      delete_vrna_path_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_path___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "path___str__" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  {
    try {
      result = vrna_path_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *path_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_path_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *path_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_new_path_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_options_s *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_path_options", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_path_options_s *)new_vrna_path_options_s();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_path_options_s, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_path_options(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_path_options_s *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_path_options_s, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_path_options" "', argument " "1"" of type '" "vrna_path_options_s *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_options_s * >(argp1);
  {
    try {
      delete_vrna_path_options_s(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *path_options_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_path_options_s, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *path_options_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_path_options_findpath(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  int arg1 = 10 ;
  unsigned int arg2 = VRNA_PATH_TYPE_DOT_BRACKET ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"width",  (char *)"type",  NULL 
  };
  vrna_path_options_s *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:path_options_findpath", kwnames, &obj0, &obj1)) SWIG_fail;
  if (obj0) {
    ecode1 = SWIG_AsVal_int(obj0, &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "path_options_findpath" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "path_options_findpath" "', argument " "2"" of type '" "unsigned int""'");
    } 
    arg2 = static_cast< unsigned int >(val2);
  }
  {
    try {
      result = (vrna_path_options_s *)my_path_options_findpath(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_path_options_s, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_get_path(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"seq",  (char *)"s1",  (char *)"s2",  (char *)"maxkeep",  NULL 
  };
  std::vector< vrna_path_t,std::allocator< vrna_path_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:get_path", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "get_path" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "get_path" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "get_path" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "get_path" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = my_get_path(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_path_t,std::allocator< vrna_path_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_find_saddle(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int arg4 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"seq",  (char *)"s1",  (char *)"s2",  (char *)"width",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:find_saddle", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "find_saddle" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "find_saddle" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "find_saddle" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "find_saddle" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (int)find_saddle((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_free_path(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_path_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  char * kwnames[] = {
    (char *)"path",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:free_path", kwnames, &obj0)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_path_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "free_path" "', argument " "1"" of type '" "vrna_path_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_path_t * >(argp1);
  {
    try {
      free_path(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_heat_capacity_result_temperature_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  heat_capacity_result *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "heat_capacity_result_temperature_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heat_capacity_result_temperature_set" "', argument " "1"" of type '" "heat_capacity_result *""'"); 
  }
  arg1 = reinterpret_cast< heat_capacity_result * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "heat_capacity_result_temperature_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->temperature = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_heat_capacity_result_temperature_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  heat_capacity_result *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heat_capacity_result_temperature_get" "', argument " "1"" of type '" "heat_capacity_result *""'"); 
  }
  arg1 = reinterpret_cast< heat_capacity_result * >(argp1);
  result = (float) ((arg1)->temperature);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_heat_capacity_result_heat_capacity_set(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  heat_capacity_result *arg1 = 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "heat_capacity_result_heat_capacity_set", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heat_capacity_result_heat_capacity_set" "', argument " "1"" of type '" "heat_capacity_result *""'"); 
  }
  arg1 = reinterpret_cast< heat_capacity_result * >(argp1);
  ecode2 = SWIG_AsVal_float(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "heat_capacity_result_heat_capacity_set" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->heat_capacity = arg2;
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_heat_capacity_result_heat_capacity_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  heat_capacity_result *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  float result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heat_capacity_result_heat_capacity_get" "', argument " "1"" of type '" "heat_capacity_result *""'"); 
  }
  arg1 = reinterpret_cast< heat_capacity_result * >(argp1);
  result = (float) ((arg1)->heat_capacity);
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_heat_capacity_result___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  heat_capacity_result *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "heat_capacity_result___str__" "', argument " "1"" of type '" "heat_capacity_result *""'"); 
  }
  arg1 = reinterpret_cast< heat_capacity_result * >(argp1);
  {
    try {
      result = heat_capacity_result___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_heat_capacity_result(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  heat_capacity_result *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_heat_capacity_result", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (heat_capacity_result *)new heat_capacity_result();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_heat_capacity_result(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  heat_capacity_result *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_heat_capacity_result" "', argument " "1"" of type '" "heat_capacity_result *""'"); 
  }
  arg1 = reinterpret_cast< heat_capacity_result * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *heat_capacity_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_heat_capacity_result, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *heat_capacity_result_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_HeatCapacityVector_iterator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  PyObject **arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  swig::SwigPyIterator *result = 0 ;
  
  arg2 = &swig_obj[0];
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_iterator" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (swig::SwigPyIterator *)std_vector_Sl_heat_capacity_result_Sg__iterator(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  if (!result) SWIG_fail;
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__SwigPyIterator, SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___nonzero__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___nonzero__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_heat_capacity_result_Sg____nonzero__((std::vector< heat_capacity_result > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___bool__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___bool__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (bool)std_vector_Sl_heat_capacity_result_Sg____bool__((std::vector< heat_capacity_result > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___len__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___len__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = std_vector_Sl_heat_capacity_result_Sg____len__((std::vector< heat_capacity_result > const *)arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___getslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::difference_type arg2 ;
  std::vector< heat_capacity_result >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HeatCapacityVector___getslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___getslice__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector___getslice__" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HeatCapacityVector___getslice__" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< heat_capacity_result >::difference_type >(val3);
  {
    try {
      try {
        result = (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *)std_vector_Sl_heat_capacity_result_Sg____getslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___setslice____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::difference_type arg2 ;
  std::vector< heat_capacity_result >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___setslice__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector___setslice__" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HeatCapacityVector___setslice__" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< heat_capacity_result >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____setslice____SWIG_0(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___setslice____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::difference_type arg2 ;
  std::vector< heat_capacity_result >::difference_type arg3 ;
  std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___setslice__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector___setslice__" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HeatCapacityVector___setslice__" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< heat_capacity_result >::difference_type >(val3);
  {
    std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *ptr = (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *)0;
    res4 = swig::asptr(swig_obj[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HeatCapacityVector___setslice__" "', argument " "4"" of type '" "std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector___setslice__" "', argument " "4"" of type '" "std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &""'"); 
    }
    arg4 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____setslice____SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &)*arg4);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res4)) delete arg4;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___setslice__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HeatCapacityVector___setslice__", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_HeatCapacityVector___setslice____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_ptrdiff_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = swig::asptr(argv[3], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HeatCapacityVector___setslice____SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HeatCapacityVector___setslice__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::__setslice__(std::vector< heat_capacity_result >::difference_type,std::vector< heat_capacity_result >::difference_type)\n"
    "    std::vector< heat_capacity_result >::__setslice__(std::vector< heat_capacity_result >::difference_type,std::vector< heat_capacity_result >::difference_type,std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___delslice__(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::difference_type arg2 ;
  std::vector< heat_capacity_result >::difference_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  ptrdiff_t val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HeatCapacityVector___delslice__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___delslice__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector___delslice__" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::difference_type >(val2);
  ecode3 = SWIG_AsVal_ptrdiff_t(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HeatCapacityVector___delslice__" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg3 = static_cast< std::vector< heat_capacity_result >::difference_type >(val3);
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____delslice__(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___delitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___delitem__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector___delitem__" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::difference_type >(val2);
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____delitem____SWIG_0(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___getitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___getitem__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector___getitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        result = (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *)std_vector_Sl_heat_capacity_result_Sg____getitem____SWIG_0(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___setitem____SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___setitem__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *ptr = (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *)0;
    res3 = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HeatCapacityVector___setitem__" "', argument " "3"" of type '" "std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector___setitem__" "', argument " "3"" of type '" "std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &""'"); 
    }
    arg3 = ptr;
  }
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____setitem____SWIG_0(arg1,arg2,(std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (SWIG_IsNewObj(res3)) delete arg3;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___setitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___setitem__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector___setitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____setitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___delitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  SWIGPY_SLICEOBJECT *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___delitem__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    if (!PySlice_Check(swig_obj[1])) {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector___delitem__" "', argument " "2"" of type '" "SWIGPY_SLICEOBJECT *""'");
    }
    arg2 = (SWIGPY_SLICEOBJECT *) swig_obj[1];
  }
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____delitem____SWIG_1(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      } catch(std::invalid_argument &_e) {
        SWIG_exception_fail(SWIG_ValueError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___delitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HeatCapacityVector___delitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HeatCapacityVector___delitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HeatCapacityVector___delitem____SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HeatCapacityVector___delitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::__delitem__(std::vector< heat_capacity_result >::difference_type)\n"
    "    std::vector< heat_capacity_result >::__delitem__(SWIGPY_SLICEOBJECT *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___getitem____SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::difference_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  std::vector< heat_capacity_result >::value_type *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___getitem__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector___getitem__" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::difference_type >(val2);
  {
    try {
      try {
        result = (std::vector< heat_capacity_result >::value_type *) &std_vector_Sl_heat_capacity_result_Sg____getitem____SWIG_1((std::vector< heat_capacity_result > const *)arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< heat_capacity_result >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___getitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HeatCapacityVector___getitem__", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HeatCapacityVector___getitem____SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HeatCapacityVector___getitem____SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HeatCapacityVector___getitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::__getitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< heat_capacity_result >::__getitem__(std::vector< heat_capacity_result >::difference_type) const\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___setitem____SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::difference_type arg2 ;
  std::vector< heat_capacity_result >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector___setitem__" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector___setitem__" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::difference_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::difference_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HeatCapacityVector___setitem__" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector___setitem__" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp3);
  {
    try {
      try {
        std_vector_Sl_heat_capacity_result_Sg____setitem____SWIG_2(arg1,SWIG_STD_MOVE(arg2),(heat_capacity_result const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector___setitem__(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HeatCapacityVector___setitem__", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        return _wrap_HeatCapacityVector___setitem____SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        _v = PySlice_Check(argv[1]);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HeatCapacityVector___setitem____SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HeatCapacityVector___setitem____SWIG_2(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HeatCapacityVector___setitem__'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::__setitem__(SWIGPY_SLICEOBJECT *,std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > const &)\n"
    "    std::vector< heat_capacity_result >::__setitem__(SWIGPY_SLICEOBJECT *)\n"
    "    std::vector< heat_capacity_result >::__setitem__(std::vector< heat_capacity_result >::difference_type,std::vector< heat_capacity_result >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_pop(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::value_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_pop" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      try {
        result = std_vector_Sl_heat_capacity_result_Sg__pop(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_exception_fail(SWIG_IndexError, (&_e)->what());
      }
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< heat_capacity_result >::value_type(result)), SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_append(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HeatCapacityVector_append", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_append" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeatCapacityVector_append" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector_append" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp2);
  {
    try {
      std_vector_Sl_heat_capacity_result_Sg__append(arg1,(heat_capacity_result const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeatCapacityVector__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **SWIGUNUSEDPARM(swig_obj)) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *result = 0 ;
  
  (void)self;
  if ((nobjs < 0) || (nobjs > 0)) SWIG_fail;
  {
    try {
      result = (std::vector< heat_capacity_result > *)new std::vector< heat_capacity_result >();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeatCapacityVector__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  std::vector< heat_capacity_result > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  {
    std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *ptr = (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *)0;
    res1 = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HeatCapacityVector" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const &""'"); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HeatCapacityVector" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const &""'"); 
    }
    arg1 = ptr;
  }
  {
    try {
      result = (std::vector< heat_capacity_result > *)new std::vector< heat_capacity_result >((std::vector< heat_capacity_result > const &)*arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_POINTER_NEW |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return resultobj;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_empty(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  bool result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_empty" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (bool)((std::vector< heat_capacity_result > const *)arg1)->empty();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_bool(static_cast< bool >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_size(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_size" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = ((std::vector< heat_capacity_result > const *)arg1)->size();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_swap(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"v",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HeatCapacityVector_swap", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_swap" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_std__vectorT_heat_capacity_result_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeatCapacityVector_swap" "', argument " "2"" of type '" "std::vector< heat_capacity_result > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector_swap" "', argument " "2"" of type '" "std::vector< heat_capacity_result > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp2);
  {
    try {
      (arg1)->swap(*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_begin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_begin" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (arg1)->begin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< heat_capacity_result >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_end(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_end" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (arg1)->end();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< heat_capacity_result >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_rbegin(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_rbegin" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (arg1)->rbegin();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< heat_capacity_result >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_rend(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::reverse_iterator result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_rend" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (arg1)->rend();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< heat_capacity_result >::reverse_iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_clear(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_clear" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      (arg1)->clear();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_get_allocator(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  SwigValueWrapper< std::allocator< heat_capacity_result > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_get_allocator" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = ((std::vector< heat_capacity_result > const *)arg1)->get_allocator();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new std::vector< heat_capacity_result >::allocator_type(result)), SWIGTYPE_p_std__allocatorT_heat_capacity_result_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeatCapacityVector__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result >::size_type arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  std::vector< heat_capacity_result > *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HeatCapacityVector" "', argument " "1"" of type '" "std::vector< heat_capacity_result >::size_type""'");
  } 
  arg1 = static_cast< std::vector< heat_capacity_result >::size_type >(val1);
  {
    try {
      result = (std::vector< heat_capacity_result > *)new std::vector< heat_capacity_result >(SWIG_STD_MOVE(arg1));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_pop_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_pop_back" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      (arg1)->pop_back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_resize__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_resize" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector_resize" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::size_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::size_type >(val2);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_erase__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  std::vector< heat_capacity_result >::iterator result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_erase" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_erase" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_erase" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_heat_capacity_result_Sg__erase__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< heat_capacity_result >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_erase__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::iterator arg2 ;
  std::vector< heat_capacity_result >::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  swig::SwigPyIterator *iter3 = 0 ;
  int res3 ;
  std::vector< heat_capacity_result >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_erase" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_erase" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_erase" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], SWIG_as_voidptrptr(&iter3), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res3) || !iter3) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_erase" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter3);
    if (iter_t) {
      arg3 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_erase" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::iterator""'");
    }
  }
  {
    try {
      result = std_vector_Sl_heat_capacity_result_Sg__erase__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< heat_capacity_result >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_erase(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HeatCapacityVector_erase", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter) != 0));
      if (_v) {
        return _wrap_HeatCapacityVector_erase__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter) != 0));
      if (_v) {
        swig::SwigPyIterator *iter = 0;
        int res = SWIG_ConvertPtr(argv[2], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
        _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter) != 0));
        if (_v) {
          return _wrap_HeatCapacityVector_erase__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HeatCapacityVector_erase'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::erase(std::vector< heat_capacity_result >::iterator)\n"
    "    std::vector< heat_capacity_result >::erase(std::vector< heat_capacity_result >::iterator,std::vector< heat_capacity_result >::iterator)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_new_HeatCapacityVector__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result >::size_type arg1 ;
  std::vector< heat_capacity_result >::value_type *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  std::vector< heat_capacity_result > *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  ecode1 = SWIG_AsVal_size_t(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_HeatCapacityVector" "', argument " "1"" of type '" "std::vector< heat_capacity_result >::size_type""'");
  } 
  arg1 = static_cast< std::vector< heat_capacity_result >::size_type >(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_HeatCapacityVector" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "new_HeatCapacityVector" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp2);
  {
    try {
      result = (std::vector< heat_capacity_result > *)new std::vector< heat_capacity_result >(SWIG_STD_MOVE(arg1),(std::vector< heat_capacity_result >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_HeatCapacityVector(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_HeatCapacityVector", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 0) {
    return _wrap_new_HeatCapacityVector__SWIG_0(self, argc, argv);
  }
  if (argc == 1) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_HeatCapacityVector__SWIG_2(self, argc, argv);
    }
  }
  if (argc == 1) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HeatCapacityVector__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_HeatCapacityVector__SWIG_3(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_HeatCapacityVector'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::vector()\n"
    "    std::vector< heat_capacity_result >::vector(std::vector< heat_capacity_result > const &)\n"
    "    std::vector< heat_capacity_result >::vector(std::vector< heat_capacity_result >::size_type)\n"
    "    std::vector< heat_capacity_result >::vector(std::vector< heat_capacity_result >::size_type,std::vector< heat_capacity_result >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_push_back(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::value_type *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HeatCapacityVector_push_back", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_push_back" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeatCapacityVector_push_back" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector_push_back" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp2);
  {
    try {
      (arg1)->push_back((std::vector< heat_capacity_result >::value_type const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_front(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_front" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (std::vector< heat_capacity_result >::value_type *) &((std::vector< heat_capacity_result > const *)arg1)->front();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< heat_capacity_result >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_back(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::value_type *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_back" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = (std::vector< heat_capacity_result >::value_type *) &((std::vector< heat_capacity_result > const *)arg1)->back();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_heat_capacity_result, 0 |  0 );
  if (!swig::container_owner<swig::traits<std::vector< heat_capacity_result >::value_type>::category>::back_reference(resultobj, swig_obj[0]) && PyErr_Occurred()) {
    SWIG_fail;
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_assign(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::size_type arg2 ;
  std::vector< heat_capacity_result >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  (char *)"x",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:HeatCapacityVector_assign", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_assign" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector_assign" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::size_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::size_type >(val2);
  res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HeatCapacityVector_assign" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector_assign" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp3);
  {
    try {
      (arg1)->assign(SWIG_STD_MOVE(arg2),(std::vector< heat_capacity_result >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_resize__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::size_type arg2 ;
  std::vector< heat_capacity_result >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_resize" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector_resize" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::size_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::size_type >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HeatCapacityVector_resize" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector_resize" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp3);
  {
    try {
      (arg1)->resize(SWIG_STD_MOVE(arg2),(std::vector< heat_capacity_result >::value_type const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_resize(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HeatCapacityVector_resize", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HeatCapacityVector_resize__SWIG_0(self, argc, argv);
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HeatCapacityVector_resize__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HeatCapacityVector_resize'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::resize(std::vector< heat_capacity_result >::size_type)\n"
    "    std::vector< heat_capacity_result >::resize(std::vector< heat_capacity_result >::size_type,std::vector< heat_capacity_result >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_insert__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::iterator arg2 ;
  std::vector< heat_capacity_result >::value_type *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  std::vector< heat_capacity_result >::iterator result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_insert" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_insert" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_insert" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
    }
  }
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "HeatCapacityVector_insert" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector_insert" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg3 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp3);
  {
    try {
      result = std_vector_Sl_heat_capacity_result_Sg__insert__SWIG_0(arg1,SWIG_STD_MOVE(arg2),(heat_capacity_result const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(swig::make_output_iterator(static_cast< const std::vector< heat_capacity_result >::iterator & >(result)),
    swig::SwigPyIterator::descriptor(),SWIG_POINTER_OWN);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_insert__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::iterator arg2 ;
  std::vector< heat_capacity_result >::size_type arg3 ;
  std::vector< heat_capacity_result >::value_type *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::SwigPyIterator *iter2 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_insert" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], SWIG_as_voidptrptr(&iter2), swig::SwigPyIterator::descriptor(), 0);
  if (!SWIG_IsOK(res2) || !iter2) {
    SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_insert" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
  } else {
    swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *iter_t = dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter2);
    if (iter_t) {
      arg2 = iter_t->get_current();
    } else {
      SWIG_exception_fail(SWIG_ArgError(SWIG_TypeError), "in method '" "HeatCapacityVector_insert" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::iterator""'");
    }
  }
  ecode3 = SWIG_AsVal_size_t(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "HeatCapacityVector_insert" "', argument " "3"" of type '" "std::vector< heat_capacity_result >::size_type""'");
  } 
  arg3 = static_cast< std::vector< heat_capacity_result >::size_type >(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_heat_capacity_result,  0  | 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "HeatCapacityVector_insert" "', argument " "4"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "HeatCapacityVector_insert" "', argument " "4"" of type '" "std::vector< heat_capacity_result >::value_type const &""'"); 
  }
  arg4 = reinterpret_cast< std::vector< heat_capacity_result >::value_type * >(argp4);
  {
    try {
      std_vector_Sl_heat_capacity_result_Sg__insert__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),(heat_capacity_result const &)*arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_insert(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "HeatCapacityVector_insert", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter) != 0));
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HeatCapacityVector_insert__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< heat_capacity_result,std::allocator< heat_capacity_result > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      swig::SwigPyIterator *iter = 0;
      int res = SWIG_ConvertPtr(argv[1], SWIG_as_voidptrptr(&iter), swig::SwigPyIterator::descriptor(), 0);
      _v = (SWIG_IsOK(res) && iter && (dynamic_cast<swig::SwigPyIterator_T<std::vector< heat_capacity_result >::iterator > *>(iter) != 0));
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_ConvertPtr(argv[3], 0, SWIGTYPE_p_heat_capacity_result, SWIG_POINTER_NO_NULL | 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HeatCapacityVector_insert__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'HeatCapacityVector_insert'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    std::vector< heat_capacity_result >::insert(std::vector< heat_capacity_result >::iterator,std::vector< heat_capacity_result >::value_type const &)\n"
    "    std::vector< heat_capacity_result >::insert(std::vector< heat_capacity_result >::iterator,std::vector< heat_capacity_result >::size_type,std::vector< heat_capacity_result >::value_type const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_reserve(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  std::vector< heat_capacity_result >::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"n",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:HeatCapacityVector_reserve", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_reserve" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "HeatCapacityVector_reserve" "', argument " "2"" of type '" "std::vector< heat_capacity_result >::size_type""'");
  } 
  arg2 = static_cast< std::vector< heat_capacity_result >::size_type >(val2);
  {
    try {
      (arg1)->reserve(SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_HeatCapacityVector_capacity(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< heat_capacity_result >::size_type result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeatCapacityVector_capacity" "', argument " "1"" of type '" "std::vector< heat_capacity_result > const *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      result = ((std::vector< heat_capacity_result > const *)arg1)->capacity();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_size_t(static_cast< size_t >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_HeatCapacityVector(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  std::vector< heat_capacity_result > *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HeatCapacityVector" "', argument " "1"" of type '" "std::vector< heat_capacity_result > *""'"); 
  }
  arg1 = reinterpret_cast< std::vector< heat_capacity_result > * >(argp1);
  {
    try {
      delete arg1;
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *HeatCapacityVector_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_std__vectorT_heat_capacity_result_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *HeatCapacityVector_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_heat_capacity(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  float arg2 = 0. ;
  float arg3 = 100. ;
  float arg4 = 1. ;
  unsigned int arg5 = 2U ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"T_min",  (char *)"T_max",  (char *)"T_increment",  (char *)"mpoints",  NULL 
  };
  std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:heat_capacity", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "heat_capacity" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj1) {
    ecode2 = SWIG_AsVal_float(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "heat_capacity" "', argument " "2"" of type '" "float""'");
    } 
    arg2 = static_cast< float >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_float(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "heat_capacity" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = static_cast< float >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_float(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "heat_capacity" "', argument " "4"" of type '" "float""'");
    } 
    arg4 = static_cast< float >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "heat_capacity" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = my_heat_capacity(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fc_add_pycallback(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"PyFunc",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fc_add_pycallback", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fc_add_pycallback" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  {
    try {
      fc_add_pycallback(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fc_add_pydata(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"data",  (char *)"PyFuncOrNone",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fc_add_pydata", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fc_add_pydata" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    if(obj2 != Py_None){
      if (!PyCallable_Check(obj2)) {
        PyErr_SetString(PyExc_TypeError, "Need a callable object!");
        return NULL;
      }
    }
    arg3 = obj2;
  }
  {
    try {
      fc_add_pydata(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sc_add_f_pycallback(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"callback",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:sc_add_f_pycallback", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sc_add_f_pycallback" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    try {
      result = (int)sc_add_f_pycallback(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sc_add_bt_pycallback(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"PyFunc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:sc_add_bt_pycallback", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sc_add_bt_pycallback" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  {
    try {
      result = (int)sc_add_bt_pycallback(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sc_add_exp_f_pycallback(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"PyFunc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:sc_add_exp_f_pycallback", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sc_add_exp_f_pycallback" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  {
    try {
      result = (int)sc_add_exp_f_pycallback(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sc_add_pydata(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"data",  (char *)"callback",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:sc_add_pydata", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sc_add_pydata" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    try {
      result = (int)sc_add_pydata(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ud_set_pydata(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"data",  (char *)"PyFuncOrNone",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ud_set_pydata", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ud_set_pydata" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    if(obj2 != Py_None){
      if (!PyCallable_Check(obj2)) {
        PyErr_SetString(PyExc_TypeError, "Need a callable object!");
        return NULL;
      }
    }
    arg3 = obj2;
  }
  {
    try {
      ud_set_pydata(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ud_set_prod_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"prod_cb",  (char *)"eval_cb",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ud_set_prod_cb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ud_set_prod_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    try {
      ud_set_prod_cb(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ud_set_exp_prod_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"prod_cb",  (char *)"eval_cb",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ud_set_exp_prod_cb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ud_set_exp_prod_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    try {
      ud_set_exp_prod_cb(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ud_set_prob_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"vc",  (char *)"setter",  (char *)"getter",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:ud_set_prob_cb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ud_set_prob_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    try {
      ud_set_prob_cb(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lfold_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"window_size",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:Lfold_cb", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lfold_cb" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lfold_cb" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (!PyCallable_Check(obj2)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg3 = obj2;
  }
  {
    arg4 = obj3;
  }
  {
    try {
      result = (float)my_Lfold_cb(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_Lfoldz_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  int arg2 ;
  double arg3 ;
  PyObject *arg4 = 0 ;
  PyObject *arg5 = 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"string",  (char *)"window_size",  (char *)"min_z",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:Lfoldz_cb", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Lfoldz_cb" "', argument " "1"" of type '" "char *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Lfoldz_cb" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Lfoldz_cb" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  {
    if (!PyCallable_Check(obj3)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg4 = obj3;
  }
  {
    arg5 = obj4;
  }
  {
    try {
      result = (float)my_Lfoldz_cb(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_aliLfold_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  int arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"alignment",  (char *)"window_size",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:aliLfold_cb", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "aliLfold_cb" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "aliLfold_cb" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (!PyCallable_Check(obj2)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg3 = obj2;
  }
  {
    arg4 = obj3;
  }
  {
    try {
      result = (float)my_aliLfold_cb(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pfl_fold_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  PyObject *arg4 = 0 ;
  PyObject *arg5 = Py_None ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"window_size",  (char *)"max_bp_span",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:pfl_fold_cb", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "pfl_fold_cb" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pfl_fold_cb" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pfl_fold_cb" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    if (!PyCallable_Check(obj3)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg4 = obj3;
  }
  if (obj4) {
    {
      arg5 = obj4;
    }
  }
  {
    try {
      result = (int)pfl_fold_cb(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pfl_fold_up_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  PyObject *arg5 = 0 ;
  PyObject *arg6 = Py_None ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"sequence",  (char *)"ulength",  (char *)"window_size",  (char *)"max_bp_span",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:pfl_fold_up_cb", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj0, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "pfl_fold_up_cb" "', argument " "1"" of type '" "std::string""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pfl_fold_up_cb" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pfl_fold_up_cb" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pfl_fold_up_cb" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if (!PyCallable_Check(obj4)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg5 = obj4;
  }
  if (obj5) {
    {
      arg6 = obj5;
    }
  }
  {
    try {
      result = (int)pfl_fold_up_cb(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sc_multi_cb_add_pycallback(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  PyObject *arg5 = 0 ;
  PyObject *arg6 = 0 ;
  unsigned int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"fc",  (char *)"f",  (char *)"f_exp",  (char *)"data",  (char *)"data_prepare",  (char *)"data_free",  (char *)"decomp_type",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOO:sc_multi_cb_add_pycallback", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sc_multi_cb_add_pycallback" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    arg4 = obj3;
  }
  {
    arg5 = obj4;
  }
  {
    arg6 = obj5;
  }
  ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "sc_multi_cb_add_pycallback" "', argument " "7"" of type '" "unsigned int""'");
  } 
  arg7 = static_cast< unsigned int >(val7);
  {
    try {
      result = (unsigned int)sc_multi_cb_add_pycallback(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_params_reset(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  vrna_md_t *arg2 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"md",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:fold_compound_params_reset", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_params_reset" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_params_reset" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      vrna_fold_compound_t_params_reset(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_params_subst(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  vrna_param_t *arg2 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"par",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:fold_compound_params_subst", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_params_subst" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_param_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_params_subst" "', argument " "2"" of type '" "vrna_param_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_param_t * >(argp2);
  }
  {
    try {
      vrna_fold_compound_t_params_subst(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_params_rescale__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_params_rescale" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_exp_params_rescale__SWIG_0(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_params_rescale__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_params_rescale" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_exp_params_rescale" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      vrna_fold_compound_t_exp_params_rescale__SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_params_rescale(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_exp_params_rescale", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_fold_compound_exp_params_rescale__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_fold_compound_exp_params_rescale__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_exp_params_rescale'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::exp_params_rescale(void)\n"
    "    vrna_fold_compound_t::exp_params_rescale(double)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_params_reset(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  vrna_md_t *arg2 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"md",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:fold_compound_exp_params_reset", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_params_reset" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_exp_params_reset" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  {
    try {
      vrna_fold_compound_t_exp_params_reset(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_params_subst(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  vrna_exp_param_t *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"par",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_exp_params_subst", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_params_subst" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_exp_params_subst" "', argument " "2"" of type '" "vrna_exp_param_t *""'"); 
  }
  arg2 = reinterpret_cast< vrna_exp_param_t * >(argp2);
  {
    try {
      vrna_fold_compound_t_exp_params_subst(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_plist_from_probs(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"cutoff",  NULL 
  };
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_plist_from_probs", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_plist_from_probs" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_plist_from_probs" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = vrna_fold_compound_t_plist_from_probs(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_db_from_probs(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_db_from_probs" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = vrna_fold_compound_t_db_from_probs(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_constraints_add(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 = VRNA_OPTION_MFE ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"constraint",  (char *)"options",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_constraints_add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_constraints_add" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_constraints_add" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_constraints_add" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      vrna_fold_compound_t_constraints_add(arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_init" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_hc_init(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_add_up(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 = VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"option",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_hc_add_up", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_add_up" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_hc_add_up" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_hc_add_up" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      vrna_fold_compound_t_hc_add_up(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_add_up_strand(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  int arg3 = -1 ;
  unsigned int arg4 = VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"strand",  (char *)"option",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:fold_compound_hc_add_up_strand", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_add_up_strand" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_hc_add_up_strand" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_hc_add_up_strand" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_hc_add_up_strand" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      vrna_fold_compound_t_hc_add_up_strand(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_add_bp_nonspecific(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  int arg3 ;
  unsigned int arg4 = VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"d",  (char *)"option",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:fold_compound_hc_add_bp_nonspecific", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_add_bp_nonspecific" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_hc_add_bp_nonspecific" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_hc_add_bp_nonspecific" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_hc_add_bp_nonspecific" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      vrna_fold_compound_t_hc_add_bp_nonspecific(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_add_bp(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 = VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  (char *)"option",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:fold_compound_hc_add_bp", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_add_bp" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_hc_add_bp" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_hc_add_bp" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_hc_add_bp" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      vrna_fold_compound_t_hc_add_bp(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_add_bp_strand(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int arg4 = -1 ;
  int arg5 = -1 ;
  unsigned int arg6 = VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  (char *)"strand_i",  (char *)"strand_j",  (char *)"option",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OOO:fold_compound_hc_add_bp_strand", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_add_bp_strand" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_hc_add_bp_strand" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_hc_add_bp_strand" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_hc_add_bp_strand" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_hc_add_bp_strand" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  if (obj5) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fold_compound_hc_add_bp_strand" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      vrna_fold_compound_t_hc_add_bp_strand(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_add_from_db(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  char *arg2 = 0 ;
  unsigned int arg3 = VRNA_CONSTRAINT_DB_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"constraint",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_hc_add_from_db", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_add_from_db" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_hc_add_from_db" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_hc_add_from_db" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_hc_add_from_db(arg1,(char const *)arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_remove" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_sc_remove(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_init(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_init" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_sc_init(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_up__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  double arg3 ;
  unsigned int arg4 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_up" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_sc_add_up" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_add_up" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_up" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_up__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_up__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_up" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_up" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_add_up" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_up__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_up(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_sc_add_up", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_sc_add_up__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_sc_add_up__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_sc_add_up__SWIG_0(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_sc_add_up__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_sc_add_up'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::sc_add_up(unsigned int,double,unsigned int)\n"
    "    vrna_fold_compound_t::sc_add_up(std::vector< double,std::allocator< double > >,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_bp__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  double arg4 ;
  unsigned int arg5 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_bp" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_sc_add_bp" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_add_bp" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_bp" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_sc_add_bp" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_bp__SWIG_0(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_bp__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg2 ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_bp" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_bp" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_add_bp" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_bp__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_bp(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_sc_add_bp", 0, 5, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_sc_add_bp__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_sc_add_bp__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_double(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            if (argc <= 4) {
              return _wrap_fold_compound_sc_add_bp__SWIG_0(self, argc, argv);
            }
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_fold_compound_sc_add_bp__SWIG_0(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_sc_add_bp'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::sc_add_bp(unsigned int,unsigned int,double,unsigned int)\n"
    "    vrna_fold_compound_t::sc_add_bp(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_set_bp(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg2 ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"constraints",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_set_bp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_set_bp" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_set_bp" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_set_bp" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_set_bp(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_set_up(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"constraints",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_set_up", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_set_up" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_set_up" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_set_up" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_set_up(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_set_stack__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_set_stack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_set_stack" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_set_stack" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_set_stack__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_set_stack__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > arg2 ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_set_stack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *ptr = (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_set_stack" "', argument " "2"" of type '" "std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_set_stack" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_set_stack__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_set_stack(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_sc_set_stack", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_sc_set_stack__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_sc_set_stack__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_sc_set_stack__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_sc_set_stack__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_sc_set_stack'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::sc_set_stack(std::vector< double,std::allocator< double > >,unsigned int)\n"
    "    vrna_fold_compound_t::sc_set_stack(std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > >,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_stack__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  double arg3 ;
  unsigned int arg4 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_stack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_sc_add_stack" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_add_stack" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_stack" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_stack__SWIG_0(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_stack__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  unsigned int arg4 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_stack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_stack" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_stack" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_stack" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_stack__SWIG_1(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_stack(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_sc_add_stack", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_double(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_sc_add_stack__SWIG_0(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_sc_add_stack__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< unsigned int,std::allocator< unsigned int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_sc_add_stack__SWIG_1(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_sc_add_stack__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_sc_add_stack'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::sc_add_stack(unsigned int,double,unsigned int)\n"
    "    vrna_fold_compound_t::sc_add_stack(std::vector< unsigned int,std::allocator< unsigned int > >,std::vector< double,std::allocator< double > >,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_hi_motif(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  FLT_OR_DBL arg4 ;
  unsigned int arg5 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"seq",  (char *)"structure",  (char *)"energy",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:fold_compound_sc_add_hi_motif", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_hi_motif" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_sc_add_hi_motif" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fold_compound_sc_add_hi_motif" "', argument " "3"" of type '" "char const *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_hi_motif" "', argument " "4"" of type '" "FLT_OR_DBL""'");
  } 
  arg4 = static_cast< FLT_OR_DBL >(val4);
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_sc_add_hi_motif" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_hi_motif(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_json(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg3 ;
  unsigned int arg4 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"json",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:fold_compound_sc_mod_json", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_json" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_json" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_json" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_mod_json" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_json(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_jsonfile(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg3 ;
  unsigned int arg4 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"jsonfile",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:fold_compound_sc_mod_jsonfile", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_jsonfile" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_jsonfile" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_jsonfile" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_mod_jsonfile" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_jsonfile(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  vrna_sc_mod_param_t arg2 = (vrna_sc_mod_param_t)0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg3 ;
  unsigned int arg4 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"params",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:fold_compound_sc_mod", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_sc_mod_param_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_sc_mod" "', argument " "2"" of type '" "vrna_sc_mod_param_t const""'"); 
  }
  arg2 = reinterpret_cast< vrna_sc_mod_param_t >(argp2);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod" "', argument " "3"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_mod" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod(arg1,arg2,SWIG_STD_MOVE(arg3),arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_m6A(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  unsigned int arg3 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_mod_m6A", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_m6A" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_m6A" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_mod_m6A" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_m6A(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_pseudouridine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  unsigned int arg3 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_mod_pseudouridine", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_pseudouridine" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_pseudouridine" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_mod_pseudouridine" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_pseudouridine(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_inosine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  unsigned int arg3 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_mod_inosine", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_inosine" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_inosine" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_mod_inosine" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_inosine(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_7DA(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  unsigned int arg3 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_mod_7DA", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_7DA" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_7DA" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_mod_7DA" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_7DA(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_purine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  unsigned int arg3 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_mod_purine", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_purine" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_purine" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_mod_purine" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_purine(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_mod_dihydrouridine(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< unsigned int,std::allocator< unsigned int > > arg2 ;
  unsigned int arg3 = VRNA_SC_MOD_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"modification_sites",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_mod_dihydrouridine", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_mod_dihydrouridine" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< unsigned int,std::allocator< unsigned int > > *ptr = (std::vector< unsigned int,std::allocator< unsigned int > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_mod_dihydrouridine" "', argument " "2"" of type '" "std::vector< unsigned int,std::allocator< unsigned int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_mod_dihydrouridine" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_mod_dihydrouridine(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_probing(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  vrna_probing_data_t arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_sc_probing", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_probing" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_probing_data_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_sc_probing" "', argument " "2"" of type '" "vrna_probing_data_t""'"); 
  }
  arg2 = reinterpret_cast< vrna_probing_data_t >(argp2);
  {
    try {
      result = (int)vrna_fold_compound_t_sc_probing(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_SHAPE_deigan(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  double arg3 ;
  double arg4 ;
  unsigned int arg5 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"reactivities",  (char *)"m",  (char *)"b",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:fold_compound_sc_add_SHAPE_deigan", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_SHAPE_deigan" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_SHAPE_deigan" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_add_SHAPE_deigan" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_SHAPE_deigan" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_sc_add_SHAPE_deigan" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_SHAPE_deigan(arg1,SWIG_STD_MOVE(arg2),arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_SHAPE_deigan_ali(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< std::string,std::allocator< std::string > > arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  double arg4 ;
  double arg5 ;
  unsigned int arg6 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"shape_files",  (char *)"shape_file_association",  (char *)"m",  (char *)"b",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:fold_compound_sc_add_SHAPE_deigan_ali", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_SHAPE_deigan_ali" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_SHAPE_deigan_ali" "', argument " "2"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_SHAPE_deigan_ali" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_SHAPE_deigan_ali" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  ecode5 = SWIG_AsVal_double(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_sc_add_SHAPE_deigan_ali" "', argument " "5"" of type '" "double""'");
  } 
  arg5 = static_cast< double >(val5);
  if (obj5) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fold_compound_sc_add_SHAPE_deigan_ali" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_SHAPE_deigan_ali(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_SHAPE_zarringhalam(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  double arg3 ;
  double arg4 ;
  char *arg5 = 0 ;
  unsigned int arg6 = VRNA_OPTION_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"reactivities",  (char *)"b",  (char *)"default_value",  (char *)"shape_conversion",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO|O:fold_compound_sc_add_SHAPE_zarringhalam", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_SHAPE_zarringhalam" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_SHAPE_zarringhalam" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sc_add_SHAPE_zarringhalam" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  ecode4 = SWIG_AsVal_double(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_sc_add_SHAPE_zarringhalam" "', argument " "4"" of type '" "double""'");
  } 
  arg4 = static_cast< double >(val4);
  res5 = SWIG_AsCharPtrAndSize(obj4, &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fold_compound_sc_add_SHAPE_zarringhalam" "', argument " "5"" of type '" "char const *""'");
  }
  arg5 = reinterpret_cast< char * >(buf5);
  if (obj5) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fold_compound_sc_add_SHAPE_zarringhalam" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_SHAPE_zarringhalam(arg1,SWIG_STD_MOVE(arg2),arg3,arg4,(char const *)arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return resultobj;
fail:
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_SHAPE_eddy_2(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< double,std::allocator< double > > arg2 ;
  std::vector< double,std::allocator< double > > arg3 ;
  std::vector< double,std::allocator< double > > arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"reactivities",  (char *)"unpaired_data",  (char *)"paired_data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:fold_compound_sc_add_SHAPE_eddy_2", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_SHAPE_eddy_2" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_SHAPE_eddy_2" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_SHAPE_eddy_2" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
    int res = swig::asptr(obj3, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sc_add_SHAPE_eddy_2" "', argument " "4"" of type '" "std::vector< double,std::allocator< double > >""'"); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_SHAPE_eddy_2(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"structure",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_eval_structure", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_structure" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_eval_structure" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (float)vrna_fold_compound_t_eval_structure(arg1,(char const *)arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure_pt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_structure_pt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_eval_structure_pt" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)vrna_fold_compound_t_eval_structure_pt__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure_pt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_structure_pt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_eval_structure_pt" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_eval_structure_pt" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (int)vrna_fold_compound_t_eval_structure_pt__SWIG_1(arg1,(var_array< short > const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure_pt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_eval_structure_pt", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_fold_compound_eval_structure_pt__SWIG_1(self, argc, argv);
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_fold_compound_eval_structure_pt__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_eval_structure_pt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::eval_structure_pt(std::vector< int,std::allocator< int > >)\n"
    "    vrna_fold_compound_t::eval_structure_pt(var_array< short > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure_verbose(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  char *arg2 = 0 ;
  FILE *arg3 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject *pyfile3 = NULL ;
  long start_position3 = -1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"structure",  (char *)"nullfile",  NULL 
  };
  float result;
  
  arg3 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_eval_structure_verbose", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_structure_verbose" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_eval_structure_verbose" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  if (obj2) {
    if(obj2 == Py_None){
      arg3 = NULL;
    } else {
      pyfile3 = obj2;
      arg3 = obj_to_file(obj2, &start_position3);
    }
  }
  /* pass, even if arg3 == NULL */
  {
    try {
      result = (float)vrna_fold_compound_t_eval_structure_verbose(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_eval_structure_verbose" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_eval_structure_verbose" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure_pt_verbose__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  FILE *arg3 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *pyfile3 = NULL ;
  long start_position3 = -1 ;
  int result;
  
  arg3 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_structure_pt_verbose" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_eval_structure_pt_verbose" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    if(swig_obj[2] == Py_None){
      arg3 = NULL;
    } else {
      pyfile3 = swig_obj[2];
      arg3 = obj_to_file(swig_obj[2], &start_position3);
    }
  }
  /* pass, even if arg3 == NULL */
  {
    try {
      result = (int)vrna_fold_compound_t_eval_structure_pt_verbose__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_eval_structure_pt_verbose" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_eval_structure_pt_verbose" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure_pt_verbose__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  FILE *arg3 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *pyfile3 = NULL ;
  long start_position3 = -1 ;
  int result;
  
  arg3 = NULL;
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_structure_pt_verbose" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_eval_structure_pt_verbose" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_eval_structure_pt_verbose" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  if (swig_obj[2]) {
    if(swig_obj[2] == Py_None){
      arg3 = NULL;
    } else {
      pyfile3 = swig_obj[2];
      arg3 = obj_to_file(swig_obj[2], &start_position3);
    }
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  /* pass, even if arg3 == NULL */
  {
    try {
      result = (int)vrna_fold_compound_t_eval_structure_pt_verbose__SWIG_1(arg1,(var_array< short > const &)*arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_eval_structure_pt_verbose" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_eval_structure_pt_verbose" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_structure_pt_verbose(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_eval_structure_pt_verbose", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_eval_structure_pt_verbose__SWIG_1(self, argc, argv);
        }
        int fd;
        if ((argv[2] == Py_None) ||
          (!PyLong_Check(argv[2]) &&                                /* is not an integer */
            PyObject_HasAttrString(argv[2], "fileno") &&             /* has fileno method */
            (PyObject_CallMethod(argv[2], "flush", NULL) != NULL) && /* flush() succeeded */
            ((fd = PyObject_AsFileDescriptor(argv[2])) != -1)        /* got file descriptor */
            )) {
          _v = 1;
        } else {
          _v = 0;
        }
        if (_v) {
          return _wrap_fold_compound_eval_structure_pt_verbose__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_eval_structure_pt_verbose__SWIG_0(self, argc, argv);
        }
        int fd;
        if ((argv[2] == Py_None) ||
          (!PyLong_Check(argv[2]) &&                                /* is not an integer */
            PyObject_HasAttrString(argv[2], "fileno") &&             /* has fileno method */
            (PyObject_CallMethod(argv[2], "flush", NULL) != NULL) && /* flush() succeeded */
            ((fd = PyObject_AsFileDescriptor(argv[2])) != -1)        /* got file descriptor */
            )) {
          _v = 1;
        } else {
          _v = 0;
        }
        if (_v) {
          return _wrap_fold_compound_eval_structure_pt_verbose__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_eval_structure_pt_verbose'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::eval_structure_pt_verbose(std::vector< int,std::allocator< int > >,FILE *)\n"
    "    vrna_fold_compound_t::eval_structure_pt_verbose(var_array< short > const &,FILE *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_covar_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"structure",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_eval_covar_structure", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_covar_structure" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_eval_covar_structure" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  {
    try {
      result = (float)vrna_fold_compound_t_eval_covar_structure(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_loop_pt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  std::vector< int,std::allocator< int > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_loop_pt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_eval_loop_pt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_eval_loop_pt" "', argument " "3"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (int)vrna_fold_compound_t_eval_loop_pt__SWIG_0(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_loop_pt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  var_array< short > *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_loop_pt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_eval_loop_pt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fold_compound_eval_loop_pt" "', argument " "3"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_eval_loop_pt" "', argument " "3"" of type '" "var_array< short > const &""'"); 
  }
  arg3 = reinterpret_cast< var_array< short > * >(argp3);
  {
    if ((!((*arg3).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg3).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg3).data[0]) != (*arg3).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (int)vrna_fold_compound_t_eval_loop_pt__SWIG_1(arg1,arg2,(var_array< short > const &)*arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_loop_pt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_eval_loop_pt", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_fold_compound_eval_loop_pt__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = swig::asptr(argv[2], (std::vector< int,std::allocator< int > >**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_fold_compound_eval_loop_pt__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_eval_loop_pt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::eval_loop_pt(int,std::vector< int,std::allocator< int > >)\n"
    "    vrna_fold_compound_t::eval_loop_pt(int,var_array< short > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_move(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"structure",  (char *)"m1",  (char *)"m2",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:fold_compound_eval_move", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_move" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_eval_move" "', argument " "2"" of type '" "char const *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_eval_move" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_eval_move" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (float)vrna_fold_compound_t_eval_move(arg1,(char const *)arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return resultobj;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_move_pt__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_move_pt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_eval_move_pt" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_eval_move_pt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_eval_move_pt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (int)vrna_fold_compound_t_eval_move_pt__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_move_pt__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_move_pt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_eval_move_pt" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_eval_move_pt" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_eval_move_pt" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_eval_move_pt" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (int)vrna_fold_compound_t_eval_move_pt__SWIG_1(arg1,(var_array< short > const &)*arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_move_pt(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_eval_move_pt", 0, 4, argv))) SWIG_fail;
  --argc;
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_eval_move_pt__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_eval_move_pt__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_eval_move_pt'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::eval_move_pt(std::vector< int,std::allocator< int > >,int,int)\n"
    "    vrna_fold_compound_t::eval_move_pt(var_array< short > const &,int,int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_ext_stem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_eval_ext_stem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_ext_stem" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_eval_ext_stem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_eval_ext_stem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_eval_ext_stem(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_E_hp_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_E_hp_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_E_hp_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_E_hp_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_E_hp_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_E_hp_loop(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_E_ext_hp_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_E_ext_hp_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_E_ext_hp_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_E_ext_hp_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_E_ext_hp_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_E_ext_hp_loop(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_ext_hp_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_eval_ext_hp_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_ext_hp_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_eval_ext_hp_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_eval_ext_hp_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_eval_ext_hp_loop(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_hp_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_eval_hp_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_hp_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_eval_hp_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_eval_hp_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_eval_hp_loop(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_E_hp_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_exp_E_hp_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_E_hp_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_exp_E_hp_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_exp_E_hp_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (double)vrna_fold_compound_t_exp_E_hp_loop(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_E_int_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_E_int_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_E_int_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_E_int_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_E_int_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_E_int_loop(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_eval_int_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  (char *)"k",  (char *)"l",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:fold_compound_eval_int_loop", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_eval_int_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_eval_int_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_eval_int_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_eval_int_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_eval_int_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (int)vrna_fold_compound_t_eval_int_loop(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_E_ext_int_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int temp4 ;
  int res4 = SWIG_TMPOBJ ;
  int temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_E_ext_int_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_E_ext_int_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_E_ext_int_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_E_ext_int_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_E_ext_int_loop(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_E_stack(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_E_stack", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_E_stack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_E_stack" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_E_stack" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (int)vrna_fold_compound_t_E_stack(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_E_int_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_exp_E_int_loop", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_E_int_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_exp_E_int_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_exp_E_int_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (double)vrna_fold_compound_t_exp_E_int_loop(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_E_interior_loop(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  (char *)"k",  (char *)"l",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOO:fold_compound_exp_E_interior_loop", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_E_interior_loop" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_exp_E_interior_loop" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_exp_E_interior_loop" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_exp_E_interior_loop" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_exp_E_interior_loop" "', argument " "5"" of type '" "int""'");
  } 
  arg5 = static_cast< int >(val5);
  {
    try {
      result = (double)vrna_fold_compound_t_exp_E_interior_loop(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_E_ext_stem(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_exp_E_ext_stem", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_E_ext_stem" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_exp_E_ext_stem" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_exp_E_ext_stem" "', argument " "3"" of type '" "int""'");
  } 
  arg3 = static_cast< int >(val3);
  {
    try {
      result = (double)vrna_fold_compound_t_exp_E_ext_stem(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_maxmimum_matching(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_maxmimum_matching" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (int)vrna_fold_compound_t_maxmimum_matching(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_mfe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_mfe" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_mfe(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_mfe_dimer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_mfe_dimer" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_mfe_dimer(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_benchmark(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  int arg3 = 0 ;
  unsigned int arg4 = 8U ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"gold",  (char *)"fuzzy",  (char *)"options",  NULL 
  };
  SwigValueWrapper< vrna_score_t > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:fold_compound_benchmark", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_benchmark" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_benchmark" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_benchmark" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_benchmark" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = vrna_fold_compound_t_benchmark(arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj((new vrna_score_t(result)), SWIGTYPE_p_vrna_score_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_mfe_window(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  FILE *arg2 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *pyfile2 = NULL ;
  long start_position2 = -1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"nullfile",  NULL 
  };
  float result;
  
  arg2 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:fold_compound_mfe_window", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_mfe_window" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    if(obj1 == Py_None){
      arg2 = NULL;
    } else {
      pyfile2 = obj1;
      arg2 = obj_to_file(obj1, &start_position2);
    }
  }
  /* pass, even if arg2 == NULL */
  {
    try {
      result = (float)vrna_fold_compound_t_mfe_window(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg2, pyfile2, start_position2) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_mfe_window" "', argument "
      "2"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg2, pyfile2, start_position2) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_mfe_window" "', argument "
      "2"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_mfe_window_zscore(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 ;
  FILE *arg3 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *pyfile3 = NULL ;
  long start_position3 = -1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"min_z",  (char *)"nullfile",  NULL 
  };
  float result;
  
  arg3 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_mfe_window_zscore", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_mfe_window_zscore" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_mfe_window_zscore" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (obj2) {
    if(obj2 == Py_None){
      arg3 = NULL;
    } else {
      pyfile3 = obj2;
      arg3 = obj_to_file(obj2, &start_position3);
    }
  }
  /* pass, even if arg3 == NULL */
  {
    try {
      result = (float)vrna_fold_compound_t_mfe_window_zscore(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_mfe_window_zscore" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg3, pyfile3, start_position3) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_mfe_window_zscore" "', argument "
      "3"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_zsc_filter_init(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 = -2.0 ;
  unsigned int arg3 = VRNA_ZSCORE_SETTINGS_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"min_z",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OO:fold_compound_zsc_filter_init", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_zsc_filter_init" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_double(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_zsc_filter_init" "', argument " "2"" of type '" "double""'");
    } 
    arg2 = static_cast< double >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_zsc_filter_init" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_zsc_filter_init(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_zsc_filter_update(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 ;
  unsigned int arg3 = VRNA_ZSCORE_OPTIONS_NONE ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"min_z",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_zsc_filter_update", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_zsc_filter_update" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_zsc_filter_update" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_zsc_filter_update" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_zsc_filter_update(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_zsc_filter_free(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_zsc_filter_free" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_zsc_filter_free(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_zsc_filter_on(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_zsc_filter_on" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (int)vrna_fold_compound_t_zsc_filter_on(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_zsc_filter_threshold(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_zsc_filter_threshold" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (double)vrna_fold_compound_t_zsc_filter_threshold(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_zsc_compute(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  (char *)"e",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:fold_compound_zsc_compute", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_zsc_compute" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_zsc_compute" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_zsc_compute" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_zsc_compute" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (double)vrna_fold_compound_t_zsc_compute(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_zsc_compute_raw(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  int arg4 ;
  double *arg5 = 0 ;
  double *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double temp5 ;
  int res5 = SWIG_TMPOBJ ;
  double temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  (char *)"j",  (char *)"e",  NULL 
  };
  double result;
  
  arg5 = &temp5;
  arg6 = &temp6;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:fold_compound_zsc_compute_raw", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_zsc_compute_raw" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_zsc_compute_raw" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_zsc_compute_raw" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_int(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_zsc_compute_raw" "', argument " "4"" of type '" "int""'");
  } 
  arg4 = static_cast< int >(val4);
  {
    try {
      result = (double)vrna_fold_compound_t_zsc_compute_raw(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_double, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags), 0);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_backtrack__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_backtrack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_backtrack" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (char *)vrna_fold_compound_t_backtrack__SWIG_0(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_backtrack__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_backtrack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_backtrack__SWIG_1(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_backtrack(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_backtrack", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_fold_compound_backtrack__SWIG_1(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_fold_compound_backtrack__SWIG_0(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_backtrack'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::backtrack(unsigned int,float *)\n"
    "    vrna_fold_compound_t::backtrack(float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_pf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pf" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_pf(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_mean_bp_distance(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  double result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_mean_bp_distance" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (double)vrna_fold_compound_t_mean_bp_distance(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ensemble_defect__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  unsigned int arg3 = 8U ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ensemble_defect" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_ensemble_defect" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_ensemble_defect" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (double)vrna_fold_compound_t_ensemble_defect__SWIG_0(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ensemble_defect__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< int,std::allocator< int > > arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ensemble_defect" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::vector< int,std::allocator< int > > *ptr = (std::vector< int,std::allocator< int > > *)0;
    int res = swig::asptr(swig_obj[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_ensemble_defect" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > >""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (double)vrna_fold_compound_t_ensemble_defect__SWIG_1(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ensemble_defect__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  double result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ensemble_defect" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0  | 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_ensemble_defect" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_ensemble_defect" "', argument " "2"" of type '" "var_array< short > const &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (double)vrna_fold_compound_t_ensemble_defect__SWIG_2(arg1,(var_array< short > const &)*arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ensemble_defect(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_ensemble_defect", 0, 3, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL | 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_fold_compound_ensemble_defect__SWIG_2(self, argc, argv);
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_ensemble_defect__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_ensemble_defect__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = swig::asptr(argv[1], (std::vector< int,std::allocator< int > >**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_fold_compound_ensemble_defect__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_ensemble_defect'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::ensemble_defect(std::string,unsigned int)\n"
    "    vrna_fold_compound_t::ensemble_defect(std::vector< int,std::allocator< int > >)\n"
    "    vrna_fold_compound_t::ensemble_defect(var_array< short > const &)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_positional_entropy(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< double,std::allocator< double > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_positional_entropy" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = vrna_fold_compound_t_positional_entropy(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< double,std::allocator< double > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pr_structure(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"structure",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_pr_structure", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pr_structure" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_pr_structure" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = (double)vrna_fold_compound_t_pr_structure(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pr_energy(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"e",  NULL 
  };
  double result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_pr_energy", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pr_energy" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pr_energy" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (double)vrna_fold_compound_t_pr_energy(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pf_dimer(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  float *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  float temp4 ;
  int res4 = SWIG_TMPOBJ ;
  float temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pf_dimer" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_pf_dimer(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg4)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_float, new_flags), 0);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg5)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_bpp(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  bool arg2 = false ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"symmetric",  NULL 
  };
  std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:fold_compound_bpp", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_bpp" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_bool(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_bpp" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
  }
  {
    try {
      result = vrna_fold_compound_t_bpp(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_stack_prob(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 = 1e-5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"cutoff",  NULL 
  };
  std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O:fold_compound_stack_prob", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_stack_prob" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_double(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_stack_prob" "', argument " "2"" of type '" "double""'");
    } 
    arg2 = static_cast< double >(val2);
  }
  {
    try {
      result = vrna_fold_compound_t_stack_prob(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_centroid(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_centroid" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_centroid(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_double, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_MEA__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float temp2 ;
  int res2 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg2 = &temp2;
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_MEA" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_MEA__SWIG_0(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg2)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_MEA__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 ;
  float *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  float temp3 ;
  int res3 = SWIG_TMPOBJ ;
  char *result = 0 ;
  
  arg3 = &temp3;
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_MEA" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_MEA" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    try {
      result = (char *)vrna_fold_compound_t_MEA__SWIG_1(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_float((*arg3)), 0);
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_float, new_flags), 0);
  }
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_MEA(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[3] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_MEA", 0, 2, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_fold_compound_MEA__SWIG_0(self, argc, argv);
    }
  }
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_double(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_fold_compound_MEA__SWIG_1(self, argc, argv);
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_MEA'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::MEA(float *)\n"
    "    vrna_fold_compound_t::MEA(double,float *)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (char *)vrna_fold_compound_t_pbacktrack__SWIG_0(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  free(result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack5__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack5" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack5" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (char *)vrna_fold_compound_t_pbacktrack5__SWIG_0(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack_sub__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  char *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack_sub" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack_sub" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack_sub" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    try {
      result = (char *)vrna_fold_compound_t_pbacktrack_sub__SWIG_0(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 = VRNA_PBACKTRACK_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = vrna_fold_compound_t_pbacktrack__SWIG_1(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack5__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 = VRNA_PBACKTRACK_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack5" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack5" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack5" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_pbacktrack5" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = vrna_fold_compound_t_pbacktrack5__SWIG_1(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack_sub__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  unsigned int arg5 = VRNA_PBACKTRACK_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack_sub" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack_sub" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack_sub" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_pbacktrack_sub" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_pbacktrack_sub" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = vrna_fold_compound_t_pbacktrack_sub__SWIG_1(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  vrna_pbacktrack_mem_t *arg3 = 0 ;
  unsigned int arg4 = VRNA_PBACKTRACK_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  vrna_pbacktrack_mem_t *retval3 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    if (swig_obj[2] == Py_None) {
      retval3 = new vrna_pbacktrack_mem_t();
      arg3 = retval3;
    } else {
      /* INOUT in */
      SWIG_ConvertPtr(swig_obj[2],SWIG_as_voidptrptr(&retval3), 0, SWIG_POINTER_DISOWN);
      arg3 = retval3;
    }
  }
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_pbacktrack" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = vrna_fold_compound_t_pbacktrack__SWIG_2(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  {
    PyObject *o, *o2, *o3;
    o = SWIG_NewPointerObj(SWIG_as_voidptr(retval3), SWIGTYPE_p_vrna_pbacktrack_mem_t, 1);
    if ((!resultobj) || (resultobj == Py_None)) {
      resultobj = o;
    } else {
      PyObject *o2 = resultobj;
      resultobj = PyTuple_New(1);
      PyTuple_SetItem(resultobj,0,o2);
      o3 = PyTuple_New(1);
      PyTuple_SetItem(o3,0,o);
      o2 = resultobj;
      resultobj = PySequence_Concat(o3,o2);
      Py_DECREF(o2);
      Py_DECREF(o3);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack5__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  vrna_pbacktrack_mem_t *arg4 = 0 ;
  unsigned int arg5 = VRNA_PBACKTRACK_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  vrna_pbacktrack_mem_t *retval4 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack5" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack5" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack5" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    if (swig_obj[3] == Py_None) {
      retval4 = new vrna_pbacktrack_mem_t();
      arg4 = retval4;
    } else {
      /* INOUT in */
      SWIG_ConvertPtr(swig_obj[3],SWIG_as_voidptrptr(&retval4), 0, SWIG_POINTER_DISOWN);
      arg4 = retval4;
    }
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_pbacktrack5" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = vrna_fold_compound_t_pbacktrack5__SWIG_2(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  {
    PyObject *o, *o2, *o3;
    o = SWIG_NewPointerObj(SWIG_as_voidptr(retval4), SWIGTYPE_p_vrna_pbacktrack_mem_t, 1);
    if ((!resultobj) || (resultobj == Py_None)) {
      resultobj = o;
    } else {
      PyObject *o2 = resultobj;
      resultobj = PyTuple_New(1);
      PyTuple_SetItem(resultobj,0,o2);
      o3 = PyTuple_New(1);
      PyTuple_SetItem(o3,0,o);
      o2 = resultobj;
      resultobj = PySequence_Concat(o3,o2);
      Py_DECREF(o2);
      Py_DECREF(o3);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack_sub__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  vrna_pbacktrack_mem_t *arg5 = 0 ;
  unsigned int arg6 = VRNA_PBACKTRACK_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  vrna_pbacktrack_mem_t *retval5 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  std::vector< std::string,std::allocator< std::string > > result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack_sub" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack_sub" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack_sub" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_pbacktrack_sub" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    if (swig_obj[4] == Py_None) {
      retval5 = new vrna_pbacktrack_mem_t();
      arg5 = retval5;
    } else {
      /* INOUT in */
      SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&retval5), 0, SWIG_POINTER_DISOWN);
      arg5 = retval5;
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fold_compound_pbacktrack_sub" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = vrna_fold_compound_t_pbacktrack_sub__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< std::string,std::allocator< std::string > > >(result));
  {
    PyObject *o, *o2, *o3;
    o = SWIG_NewPointerObj(SWIG_as_voidptr(retval5), SWIGTYPE_p_vrna_pbacktrack_mem_t, 1);
    if ((!resultobj) || (resultobj == Py_None)) {
      resultobj = o;
    } else {
      PyObject *o2 = resultobj;
      resultobj = PyTuple_New(1);
      PyTuple_SetItem(resultobj,0,o2);
      o3 = PyTuple_New(1);
      PyTuple_SetItem(o3,0,o);
      o2 = resultobj;
      resultobj = PySequence_Concat(o3,o2);
      Py_DECREF(o2);
      Py_DECREF(o3);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_subopt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  int arg3 = 1 ;
  FILE *arg4 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *pyfile4 = NULL ;
  long start_position4 = -1 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"delta",  (char *)"sorted",  (char *)"nullfile",  NULL 
  };
  std::vector< subopt_solution,std::allocator< subopt_solution > > result;
  
  arg4 = NULL;
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OO:fold_compound_subopt", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_subopt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_subopt" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  if (obj2) {
    ecode3 = SWIG_AsVal_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_subopt" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
  }
  if (obj3) {
    if(obj3 == Py_None){
      arg4 = NULL;
    } else {
      pyfile4 = obj3;
      arg4 = obj_to_file(obj3, &start_position4);
    }
  }
  /* pass, even if arg4 == NULL */
  {
    try {
      result = vrna_fold_compound_t_subopt(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< subopt_solution,std::allocator< subopt_solution > > >(result));
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_subopt" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return resultobj;
fail:
  if (dispose_file(&arg4, pyfile4, start_position4) == -1) {
    SWIG_exception_fail(SWIG_IOError, "closing file in method '" "fold_compound_subopt" "', argument "
      "4"" of type '" "FILE *""'");
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_subopt_zuker(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::vector< subopt_solution,std::allocator< subopt_solution > > result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_subopt_zuker" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = vrna_fold_compound_t_subopt_zuker(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< subopt_solution,std::allocator< subopt_solution > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sequence_add(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  unsigned int arg3 = VRNA_SEQUENCE_RNA ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"sequence",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sequence_add", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sequence_add" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_sequence_add" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_sequence_add" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sequence_add(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sequence_remove(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"i",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_sequence_remove", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sequence_remove" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_sequence_remove" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    try {
      result = (int)vrna_fold_compound_t_sequence_remove(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sequence_remove_all(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sequence_remove_all" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_sequence_remove_all(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sequence_prepare(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sequence_prepare" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_sequence_prepare(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ud_add_motif(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  double arg3 ;
  std::string arg4 = "" ;
  unsigned int arg5 = VRNA_UNSTRUCTURED_DOMAIN_ALL_LOOPS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"motif",  (char *)"motif_en",  (char *)"name",  (char *)"options",  NULL 
  };
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:fold_compound_ud_add_motif", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ud_add_motif" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_ud_add_motif" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_double(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_ud_add_motif" "', argument " "3"" of type '" "double""'");
  } 
  arg3 = static_cast< double >(val3);
  if (obj3) {
    {
      std::string *ptr = (std::string *)0;
      int res = SWIG_AsPtr_std_string(obj3, &ptr);
      if (!SWIG_IsOK(res) || !ptr) {
        SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_ud_add_motif" "', argument " "4"" of type '" "std::string""'"); 
      }
      arg4 = *ptr;
      if (SWIG_IsNewObj(res)) delete ptr;
    }
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_ud_add_motif" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      vrna_fold_compound_t_ud_add_motif(arg1,SWIG_STD_MOVE(arg2),arg3,SWIG_STD_MOVE(arg4),arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ud_remove(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ud_remove" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      vrna_fold_compound_t_ud_remove(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_commands_apply(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  vrna_command_s *arg2 = 0 ;
  unsigned int arg3 = VRNA_CMD_PARSE_DEFAULTS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"commands",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_commands_apply", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_commands_apply" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_vrna_command_s, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_commands_apply" "', argument " "2"" of type '" "vrna_command_s *""'"); 
  }
  arg2 = reinterpret_cast< vrna_command_s * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_commands_apply" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_commands_apply(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_file_commands_apply(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  unsigned int arg3 = VRNA_CMD_PARSE_DEFAULTS ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"filename",  (char *)"options",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_file_commands_apply", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_file_commands_apply" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_file_commands_apply" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_file_commands_apply" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (int)vrna_fold_compound_t_file_commands_apply(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_rotational_symmetry_db(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"structure",  NULL 
  };
  std::vector< unsigned int,std::allocator< unsigned int > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_rotational_symmetry_db", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_rotational_symmetry_db" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_rotational_symmetry_db" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    try {
      result = vrna_fold_compound_t_rotational_symmetry_db(arg1,SWIG_STD_MOVE(arg2));
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< unsigned int,std::allocator< unsigned int > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_neighbors(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  unsigned int arg3 = (4|8) ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"pt",  (char *)"options",  NULL 
  };
  var_array< vrna_move_t > *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_neighbors", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_neighbors" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_var_arrayT_short_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_neighbors" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_neighbors" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  if (obj2) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_neighbors" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (var_array< vrna_move_t > *)vrna_fold_compound_t_neighbors(arg1,*arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_vrna_move_t_t, SWIG_POINTER_OWN |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_move_neighbor_diff__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  SwigValueWrapper< vrna_move_t > arg3 ;
  var_array< vrna_move_t > **arg4 = 0 ;
  unsigned int arg5 = (4|8) ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  var_array< vrna_move_t > *temp4 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  var_array< vrna_move_t > *result = 0 ;
  
  {
    arg4 = &temp4;
  }
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_move_neighbor_diff" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_move_neighbor_diff" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_move_neighbor_diff" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  {
    res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_vrna_move_t,  0  | 0);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fold_compound_move_neighbor_diff" "', argument " "3"" of type '" "vrna_move_t""'"); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_move_neighbor_diff" "', argument " "3"" of type '" "vrna_move_t""'");
    } else {
      vrna_move_t * temp = reinterpret_cast< vrna_move_t * >(argp3);
      arg3 = *temp;
      if (SWIG_IsNewObj(res3)) delete temp;
    }
  }
  if (swig_obj[3]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_move_neighbor_diff" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (var_array< vrna_move_t > *)vrna_fold_compound_t_move_neighbor_diff__SWIG_0(arg1,*arg2,SWIG_STD_MOVE(arg3),*arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_vrna_move_t_t, SWIG_POINTER_OWN |  0 );
  {
    var_array<vrna_move_t> *newObj;
    *(var_array<vrna_move_t>**)&newObj = *arg4;
    
    PyObject* temp = NULL;
    if (!PyList_Check(resultobj)) {
      temp = resultobj;
      resultobj = PyList_New(1);
      PyList_SetItem(resultobj, 0, temp);
    }
    
    temp = SWIG_NewPointerObj(SWIG_as_voidptr(newObj),
      SWIGTYPE_p_var_arrayT_vrna_move_t_t,
      SWIG_POINTER_OWN | 0);
    
    PyList_Append(resultobj, temp);
    Py_DECREF(temp);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 = VRNA_PATH_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_path" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_path" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_path" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_path" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = vrna_fold_compound_t_path__SWIG_0(arg1,*arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_move_t,std::allocator< vrna_move_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 = VRNA_PATH_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_path" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_path" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_path" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_path" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = vrna_fold_compound_t_path__SWIG_1(arg1,*arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_move_t,std::allocator< vrna_move_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_path", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_path__SWIG_0(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_path__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_path__SWIG_1(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_path__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_path'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::path(std::vector< int,std::allocator< int > > &,unsigned int,unsigned int)\n"
    "    vrna_fold_compound_t::path(var_array< short > &,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_gradient__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  unsigned int arg3 = VRNA_PATH_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path_gradient" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_path_gradient" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_path_gradient" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_path_gradient" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = vrna_fold_compound_t_path_gradient__SWIG_0(arg1,*arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_move_t,std::allocator< vrna_move_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_gradient__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  unsigned int arg3 = VRNA_PATH_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > result;
  
  (void)self;
  if ((nobjs < 2) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path_gradient" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_path_gradient" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_path_gradient" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_path_gradient" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = vrna_fold_compound_t_path_gradient__SWIG_1(arg1,*arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_move_t,std::allocator< vrna_move_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_gradient(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[4] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_path_gradient", 0, 3, argv))) SWIG_fail;
  --argc;
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_path_gradient__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_path_gradient__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_path_gradient__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_path_gradient__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_path_gradient'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::path_gradient(std::vector< int,std::allocator< int > > &,unsigned int)\n"
    "    vrna_fold_compound_t::path_gradient(var_array< short > &,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_random__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::vector< int,std::allocator< int > > *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 = VRNA_PATH_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path_random" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_std__vectorT_int_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_path_random" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_path_random" "', argument " "2"" of type '" "std::vector< int,std::allocator< int > > &""'"); 
  }
  arg2 = reinterpret_cast< std::vector< int,std::allocator< int > > * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_path_random" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_path_random" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    try {
      result = vrna_fold_compound_t_path_random__SWIG_0(arg1,*arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_move_t,std::allocator< vrna_move_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_random__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 = VRNA_PATH_DEFAULT ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  std::vector< vrna_move_t,std::allocator< vrna_move_t > > result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path_random" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_path_random" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_path_random" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_path_random" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  if (swig_obj[3]) {
    ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_path_random" "', argument " "4"" of type '" "unsigned int""'");
    } 
    arg4 = static_cast< unsigned int >(val4);
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = vrna_fold_compound_t_path_random__SWIG_1(arg1,*arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_move_t,std::allocator< vrna_move_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_random(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[5] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_path_random", 0, 4, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_path_random__SWIG_0(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_path_random__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_path_random__SWIG_1(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_path_random__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_path_random'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::path_random(std::vector< int,std::allocator< int > > &,unsigned int,unsigned int)\n"
    "    vrna_fold_compound_t::path_random(var_array< short > &,unsigned int,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_findpath_saddle(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 = 1 ;
  int arg5 = INT_MAX ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"s1",  (char *)"s2",  (char *)"width",  (char *)"maxE",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:fold_compound_path_findpath_saddle", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path_findpath_saddle" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_path_findpath_saddle" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_path_findpath_saddle" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_path_findpath_saddle" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_path_findpath_saddle" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_path_findpath_saddle(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_findpath(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 = 1 ;
  int arg5 = INT_MAX-1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"s1",  (char *)"s2",  (char *)"width",  (char *)"maxE",  NULL 
  };
  std::vector< vrna_path_t,std::allocator< vrna_path_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:fold_compound_path_findpath", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path_findpath" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_path_findpath" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_path_findpath" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_path_findpath" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_path_findpath" "', argument " "5"" of type '" "int""'");
    } 
    arg5 = static_cast< int >(val5);
  }
  {
    try {
      result = vrna_fold_compound_t_path_findpath(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_path_t,std::allocator< vrna_path_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_path_direct(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  int arg4 = INT_MAX-1 ;
  vrna_path_options_s *arg5 = NULL ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"s1",  (char *)"s2",  (char *)"maxE",  (char *)"options",  NULL 
  };
  std::vector< vrna_path_t,std::allocator< vrna_path_t > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|OO:fold_compound_path_direct", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_path_direct" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj1, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_path_direct" "', argument " "2"" of type '" "std::string""'"); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(obj2, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "fold_compound_path_direct" "', argument " "3"" of type '" "std::string""'"); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_int(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_path_direct" "', argument " "4"" of type '" "int""'");
    } 
    arg4 = static_cast< int >(val4);
  }
  if (obj4) {
    res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_vrna_path_options_s, 0 |  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "fold_compound_path_direct" "', argument " "5"" of type '" "vrna_path_options_s *""'"); 
    }
    arg5 = reinterpret_cast< vrna_path_options_s * >(argp5);
  }
  {
    try {
      result = vrna_fold_compound_t_path_direct(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3),arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< vrna_path_t,std::allocator< vrna_path_t > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_heat_capacity(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float arg2 = 0. ;
  float arg3 = 100. ;
  float arg4 = 1. ;
  unsigned int arg5 = 2U ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"T_min",  (char *)"T_max",  (char *)"T_increment",  (char *)"mpoints",  NULL 
  };
  std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|OOOO:fold_compound_heat_capacity", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_heat_capacity" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  if (obj1) {
    ecode2 = SWIG_AsVal_float(obj1, &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_heat_capacity" "', argument " "2"" of type '" "float""'");
    } 
    arg2 = static_cast< float >(val2);
  }
  if (obj2) {
    ecode3 = SWIG_AsVal_float(obj2, &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_heat_capacity" "', argument " "3"" of type '" "float""'");
    } 
    arg3 = static_cast< float >(val3);
  }
  if (obj3) {
    ecode4 = SWIG_AsVal_float(obj3, &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_heat_capacity" "', argument " "4"" of type '" "float""'");
    } 
    arg4 = static_cast< float >(val4);
  }
  if (obj4) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_heat_capacity" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = vrna_fold_compound_t_heat_capacity(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = swig::from(static_cast< std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_add_auxdata(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"data",  (char *)"PyFuncOrNone",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_add_auxdata", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_add_auxdata" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  if (obj2) {
    {
      if(obj2 != Py_None){
        if (!PyCallable_Check(obj2)) {
          PyErr_SetString(PyExc_TypeError, "Need a callable object!");
          return NULL;
        }
      }
      arg3 = obj2;
    }
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_add_auxdata(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_add_callback(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"PyFunc",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_add_callback", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_add_callback" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_add_callback(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_data(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"data",  (char *)"callback",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_sc_add_data", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_data" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  if (obj2) {
    {
      arg3 = obj2;
    }
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_data(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_f(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"callback",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_sc_add_f", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_f" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_f(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_bt(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"PyFunc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_sc_add_bt", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_bt" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_bt(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_add_exp_f(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"PyFunc",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:fold_compound_sc_add_exp_f", kwnames, &obj0, &obj1)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_add_exp_f" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  {
    try {
      result = (int)vrna_fold_compound_t_sc_add_exp_f(arg1,arg2);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ud_set_data(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"data",  (char *)"free_cb",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_ud_set_data", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ud_set_data" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  if (obj2) {
    {
      arg3 = obj2;
    }
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_ud_set_data(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ud_set_prod_rule_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"prod_cb",  (char *)"eval_cb",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_ud_set_prod_rule_cb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ud_set_prod_rule_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_ud_set_prod_rule_cb(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ud_set_exp_prod_rule_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"prod_cb",  (char *)"eval_cb",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_ud_set_exp_prod_rule_cb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ud_set_exp_prod_rule_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_ud_set_exp_prod_rule_cb(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_ud_set_prob_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"setter_cb",  (char *)"getter_cb",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:fold_compound_ud_set_prob_cb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_ud_set_prob_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  {
    arg3 = obj2;
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_ud_set_prob_cb(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_subopt_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"delta",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:fold_compound_subopt_cb", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_subopt_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_subopt_cb" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  {
    if (!PyCallable_Check(obj2)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg3 = obj2;
  }
  if (obj3) {
    {
      arg4 = obj3;
    }
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_subopt_cb(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack5__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  PyObject *arg4 = 0 ;
  PyObject *arg5 = Py_None ;
  unsigned int arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack5" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack5" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack5" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    if (!PyCallable_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg4 = swig_obj[3];
  }
  if (swig_obj[4]) {
    {
      arg5 = swig_obj[4];
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fold_compound_pbacktrack5" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (unsigned int)vrna_fold_compound_t_pbacktrack5__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = Py_None ;
  unsigned int arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  if (swig_obj[3]) {
    {
      arg4 = swig_obj[3];
    }
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_pbacktrack" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = (unsigned int)vrna_fold_compound_t_pbacktrack__SWIG_3(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack_sub__SWIG_3(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  PyObject *arg5 = 0 ;
  PyObject *arg6 = Py_None ;
  unsigned int arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack_sub" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack_sub" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack_sub" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_pbacktrack_sub" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    if (!PyCallable_Check(swig_obj[4])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg5 = swig_obj[4];
  }
  if (swig_obj[5]) {
    {
      arg6 = swig_obj[5];
    }
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fold_compound_pbacktrack_sub" "', argument " "7"" of type '" "unsigned int""'");
    } 
    arg7 = static_cast< unsigned int >(val7);
  }
  {
    try {
      result = (unsigned int)vrna_fold_compound_t_pbacktrack_sub__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  vrna_pbacktrack_mem_t *arg5 = 0 ;
  unsigned int arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  vrna_pbacktrack_mem_t *retval5 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 5) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  {
    if (!PyCallable_Check(swig_obj[2])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg3 = swig_obj[2];
  }
  {
    arg4 = swig_obj[3];
  }
  {
    if (swig_obj[4] == Py_None) {
      retval5 = new vrna_pbacktrack_mem_t();
      arg5 = retval5;
    } else {
      /* INOUT in */
      SWIG_ConvertPtr(swig_obj[4],SWIG_as_voidptrptr(&retval5), 0, SWIG_POINTER_DISOWN);
      arg5 = retval5;
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fold_compound_pbacktrack" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    try {
      result = (unsigned int)vrna_fold_compound_t_pbacktrack__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    PyObject *o, *o2, *o3;
    o = SWIG_NewPointerObj(SWIG_as_voidptr(retval5), SWIGTYPE_p_vrna_pbacktrack_mem_t, 1);
    if ((!resultobj) || (resultobj == Py_None)) {
      resultobj = o;
    } else {
      PyObject *o2 = resultobj;
      resultobj = PyTuple_New(1);
      PyTuple_SetItem(resultobj,0,o2);
      o3 = PyTuple_New(1);
      PyTuple_SetItem(o3,0,o);
      o2 = resultobj;
      resultobj = PySequence_Concat(o3,o2);
      Py_DECREF(o2);
      Py_DECREF(o3);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_pbacktrack", 0, 6, argv))) SWIG_fail;
  --argc;
  if (argc == 1) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_fold_compound_pbacktrack__SWIG_0(self, argc, argv);
    }
  }
  if ((argc >= 2) && (argc <= 3)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        if (argc <= 2) {
          return _wrap_fold_compound_pbacktrack__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_pbacktrack__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_vrna_pbacktrack_mem_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_pbacktrack__SWIG_2(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_pbacktrack__SWIG_2(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_pbacktrack__SWIG_3(self, argc, argv);
          }
          _v = (argv[3] != 0);
          if (_v) {
            if (argc <= 4) {
              return _wrap_fold_compound_pbacktrack__SWIG_3(self, argc, argv);
            }
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_fold_compound_pbacktrack__SWIG_3(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_vrna_pbacktrack_mem_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              if (argc <= 5) {
                return _wrap_fold_compound_pbacktrack__SWIG_4(self, argc, argv);
              }
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_fold_compound_pbacktrack__SWIG_4(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_pbacktrack'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::pbacktrack(void)\n"
    "    vrna_fold_compound_t::pbacktrack(unsigned int,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack(unsigned int,vrna_pbacktrack_mem_t *,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack(unsigned int,PyObject *,PyObject *,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack(unsigned int,PyObject *,PyObject *,vrna_pbacktrack_mem_t *,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack5__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  PyObject *arg4 = 0 ;
  PyObject *arg5 = 0 ;
  vrna_pbacktrack_mem_t *arg6 = 0 ;
  unsigned int arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  vrna_pbacktrack_mem_t *retval6 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 6) || (nobjs > 7)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack5" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack5" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack5" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    if (!PyCallable_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg4 = swig_obj[3];
  }
  {
    arg5 = swig_obj[4];
  }
  {
    if (swig_obj[5] == Py_None) {
      retval6 = new vrna_pbacktrack_mem_t();
      arg6 = retval6;
    } else {
      /* INOUT in */
      SWIG_ConvertPtr(swig_obj[5],SWIG_as_voidptrptr(&retval6), 0, SWIG_POINTER_DISOWN);
      arg6 = retval6;
    }
  }
  if (swig_obj[6]) {
    ecode7 = SWIG_AsVal_unsigned_SS_int(swig_obj[6], &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fold_compound_pbacktrack5" "', argument " "7"" of type '" "unsigned int""'");
    } 
    arg7 = static_cast< unsigned int >(val7);
  }
  {
    try {
      result = (unsigned int)vrna_fold_compound_t_pbacktrack5__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    PyObject *o, *o2, *o3;
    o = SWIG_NewPointerObj(SWIG_as_voidptr(retval6), SWIGTYPE_p_vrna_pbacktrack_mem_t, 1);
    if ((!resultobj) || (resultobj == Py_None)) {
      resultobj = o;
    } else {
      PyObject *o2 = resultobj;
      resultobj = PyTuple_New(1);
      PyTuple_SetItem(resultobj,0,o2);
      o3 = PyTuple_New(1);
      PyTuple_SetItem(o3,0,o);
      o2 = resultobj;
      resultobj = PySequence_Concat(o3,o2);
      Py_DECREF(o2);
      Py_DECREF(o3);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack5(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[8] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_pbacktrack5", 0, 7, argv))) SWIG_fail;
  --argc;
  if (argc == 2) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_fold_compound_pbacktrack5__SWIG_0(self, argc, argv);
      }
    }
  }
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_pbacktrack5__SWIG_1(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_pbacktrack5__SWIG_1(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_vrna_pbacktrack_mem_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            if (argc <= 4) {
              return _wrap_fold_compound_pbacktrack5__SWIG_2(self, argc, argv);
            }
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_fold_compound_pbacktrack5__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 6)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            if (argc <= 4) {
              return _wrap_fold_compound_pbacktrack5__SWIG_3(self, argc, argv);
            }
            _v = (argv[4] != 0);
            if (_v) {
              if (argc <= 5) {
                return _wrap_fold_compound_pbacktrack5__SWIG_3(self, argc, argv);
              }
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_fold_compound_pbacktrack5__SWIG_3(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 6) && (argc <= 7)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            _v = (argv[4] != 0);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_vrna_pbacktrack_mem_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                if (argc <= 6) {
                  return _wrap_fold_compound_pbacktrack5__SWIG_4(self, argc, argv);
                }
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_fold_compound_pbacktrack5__SWIG_4(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_pbacktrack5'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::pbacktrack5(unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack5(unsigned int,unsigned int,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack5(unsigned int,unsigned int,vrna_pbacktrack_mem_t *,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack5(unsigned int,unsigned int,PyObject *,PyObject *,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack5(unsigned int,unsigned int,PyObject *,PyObject *,vrna_pbacktrack_mem_t *,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack_sub__SWIG_4(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  PyObject *arg5 = 0 ;
  PyObject *arg6 = 0 ;
  vrna_pbacktrack_mem_t *arg7 = 0 ;
  unsigned int arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  vrna_pbacktrack_mem_t *retval7 ;
  unsigned int val8 ;
  int ecode8 = 0 ;
  unsigned int result;
  
  (void)self;
  if ((nobjs < 7) || (nobjs > 8)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_pbacktrack_sub" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_pbacktrack_sub" "', argument " "2"" of type '" "unsigned int""'");
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_pbacktrack_sub" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_pbacktrack_sub" "', argument " "4"" of type '" "unsigned int""'");
  } 
  arg4 = static_cast< unsigned int >(val4);
  {
    if (!PyCallable_Check(swig_obj[4])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg5 = swig_obj[4];
  }
  {
    arg6 = swig_obj[5];
  }
  {
    if (swig_obj[6] == Py_None) {
      retval7 = new vrna_pbacktrack_mem_t();
      arg7 = retval7;
    } else {
      /* INOUT in */
      SWIG_ConvertPtr(swig_obj[6],SWIG_as_voidptrptr(&retval7), 0, SWIG_POINTER_DISOWN);
      arg7 = retval7;
    }
  }
  if (swig_obj[7]) {
    ecode8 = SWIG_AsVal_unsigned_SS_int(swig_obj[7], &val8);
    if (!SWIG_IsOK(ecode8)) {
      SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "fold_compound_pbacktrack_sub" "', argument " "8"" of type '" "unsigned int""'");
    } 
    arg8 = static_cast< unsigned int >(val8);
  }
  {
    try {
      result = (unsigned int)vrna_fold_compound_t_pbacktrack_sub__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  {
    PyObject *o, *o2, *o3;
    o = SWIG_NewPointerObj(SWIG_as_voidptr(retval7), SWIGTYPE_p_vrna_pbacktrack_mem_t, 1);
    if ((!resultobj) || (resultobj == Py_None)) {
      resultobj = o;
    } else {
      PyObject *o2 = resultobj;
      resultobj = PyTuple_New(1);
      PyTuple_SetItem(resultobj,0,o2);
      o3 = PyTuple_New(1);
      PyTuple_SetItem(o3,0,o);
      o2 = resultobj;
      resultobj = PySequence_Concat(o3,o2);
      Py_DECREF(o2);
      Py_DECREF(o3);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_pbacktrack_sub(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[9] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_pbacktrack_sub", 0, 8, argv))) SWIG_fail;
  --argc;
  if (argc == 3) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_fold_compound_pbacktrack_sub__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 5)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            if (argc <= 4) {
              return _wrap_fold_compound_pbacktrack_sub__SWIG_1(self, argc, argv);
            }
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_fold_compound_pbacktrack_sub__SWIG_1(self, argc, argv);
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 6)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_vrna_pbacktrack_mem_t, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              if (argc <= 5) {
                return _wrap_fold_compound_pbacktrack_sub__SWIG_2(self, argc, argv);
              }
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_fold_compound_pbacktrack_sub__SWIG_2(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 5) && (argc <= 7)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            _v = (argv[4] != 0);
            if (_v) {
              if (argc <= 5) {
                return _wrap_fold_compound_pbacktrack_sub__SWIG_3(self, argc, argv);
              }
              _v = (argv[5] != 0);
              if (_v) {
                if (argc <= 6) {
                  return _wrap_fold_compound_pbacktrack_sub__SWIG_3(self, argc, argv);
                }
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_fold_compound_pbacktrack_sub__SWIG_3(self, argc, argv);
                }
              }
            }
          }
        }
      }
    }
  }
  if ((argc >= 7) && (argc <= 8)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            _v = (argv[4] != 0);
            if (_v) {
              _v = (argv[5] != 0);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_vrna_pbacktrack_mem_t, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  if (argc <= 7) {
                    return _wrap_fold_compound_pbacktrack_sub__SWIG_4(self, argc, argv);
                  }
                  {
                    int res = SWIG_AsVal_unsigned_SS_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_fold_compound_pbacktrack_sub__SWIG_4(self, argc, argv);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_pbacktrack_sub'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::pbacktrack_sub(unsigned int,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack_sub(unsigned int,unsigned int,unsigned int,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack_sub(unsigned int,unsigned int,unsigned int,vrna_pbacktrack_mem_t *,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack_sub(unsigned int,unsigned int,unsigned int,PyObject *,PyObject *,unsigned int)\n"
    "    vrna_fold_compound_t::pbacktrack_sub(unsigned int,unsigned int,unsigned int,PyObject *,PyObject *,vrna_pbacktrack_mem_t *,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_mfe_window_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|O:fold_compound_mfe_window_cb", kwnames, &obj0, &obj1, &obj2)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_mfe_window_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    if (!PyCallable_Check(obj1)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg2 = obj1;
  }
  if (obj2) {
    {
      arg3 = obj2;
    }
  }
  {
    try {
      result = (float)vrna_fold_compound_t_mfe_window_cb(arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_mfe_window_zscore_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  double arg2 ;
  PyObject *arg3 = 0 ;
  PyObject *arg4 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"min_z",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  float result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO|O:fold_compound_mfe_window_zscore_cb", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_mfe_window_zscore_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_double(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_mfe_window_zscore_cb" "', argument " "2"" of type '" "double""'");
  } 
  arg2 = static_cast< double >(val2);
  {
    if (!PyCallable_Check(obj2)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg3 = obj2;
  }
  if (obj3) {
    {
      arg4 = obj3;
    }
  }
  {
    try {
      result = (float)vrna_fold_compound_t_mfe_window_zscore_cb(arg1,arg2,arg3,arg4);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_float(static_cast< float >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_probs_window(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  int arg2 ;
  unsigned int arg3 ;
  PyObject *arg4 = 0 ;
  PyObject *arg5 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"ulength",  (char *)"options",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO|O:fold_compound_probs_window", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_probs_window" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_int(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_probs_window" "', argument " "2"" of type '" "int""'");
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_probs_window" "', argument " "3"" of type '" "unsigned int""'");
  } 
  arg3 = static_cast< unsigned int >(val3);
  {
    if (!PyCallable_Check(obj3)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg4 = obj3;
  }
  if (obj4) {
    {
      arg5 = obj4;
    }
  }
  {
    try {
      result = (int)vrna_fold_compound_t_probs_window(arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_heat_capacity_cb(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  unsigned int arg5 ;
  PyObject *arg6 = 0 ;
  PyObject *arg7 = Py_None ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"T_min",  (char *)"T_max",  (char *)"T_increment",  (char *)"mpoints",  (char *)"PyFunc",  (char *)"data",  NULL 
  };
  PyObject *result = 0 ;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO|O:fold_compound_heat_capacity_cb", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_heat_capacity_cb" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  ecode2 = SWIG_AsVal_float(obj1, &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "fold_compound_heat_capacity_cb" "', argument " "2"" of type '" "float""'");
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(obj2, &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "fold_compound_heat_capacity_cb" "', argument " "3"" of type '" "float""'");
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(obj3, &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "fold_compound_heat_capacity_cb" "', argument " "4"" of type '" "float""'");
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "fold_compound_heat_capacity_cb" "', argument " "5"" of type '" "unsigned int""'");
  } 
  arg5 = static_cast< unsigned int >(val5);
  {
    if (!PyCallable_Check(obj5)) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg6 = obj5;
  }
  if (obj6) {
    {
      arg7 = obj6;
    }
  }
  {
    try {
      result = (PyObject *)vrna_fold_compound_t_heat_capacity_cb(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = result;
  if (!resultobj) SWIG_fail;
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_move_neighbor_diff__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  var_array< short > *arg2 = 0 ;
  vrna_move_t *arg3 = 0 ;
  PyObject *arg4 = 0 ;
  PyObject *arg5 = Py_None ;
  unsigned int arg6 = (4|8) ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int result;
  
  (void)self;
  if ((nobjs < 4) || (nobjs > 6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_move_neighbor_diff" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_var_arrayT_short_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "fold_compound_move_neighbor_diff" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_NullReferenceError, "invalid null reference " "in method '" "fold_compound_move_neighbor_diff" "', argument " "2"" of type '" "var_array< short > &""'"); 
  }
  arg2 = reinterpret_cast< var_array< short > * >(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_vrna_move_t, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "fold_compound_move_neighbor_diff" "', argument " "3"" of type '" "vrna_move_t *""'"); 
  }
  arg3 = reinterpret_cast< vrna_move_t * >(argp3);
  {
    if (!PyCallable_Check(swig_obj[3])) {
      PyErr_SetString(PyExc_TypeError, "Need a callable object!");
      return NULL;
    }
    arg4 = swig_obj[3];
  }
  if (swig_obj[4]) {
    {
      arg5 = swig_obj[4];
    }
  }
  if (swig_obj[5]) {
    ecode6 = SWIG_AsVal_unsigned_SS_int(swig_obj[5], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fold_compound_move_neighbor_diff" "', argument " "6"" of type '" "unsigned int""'");
    } 
    arg6 = static_cast< unsigned int >(val6);
  }
  {
    if ((!((*arg2).type & VAR_ARRAY_LINEAR)) ||
      (!((*arg2).type & VAR_ARRAY_ONE_BASED)) ||
      ((size_t)((*arg2).data[0]) != (*arg2).length ))
    {
      SWIG_exception(SWIG_ValueError,"Expected var_array<short> with pair_table properties, i.e. data[0] == length, type = VAR_ARRAY_LINEAR | VAR_ARRAY_ONE_BASED.");
    }
  }
  {
    try {
      result = (int)vrna_fold_compound_t_move_neighbor_diff__SWIG_1(arg1,*arg2,arg3,arg4,arg5,arg6);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_move_neighbor_diff(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[7] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "fold_compound_move_neighbor_diff", 0, 6, argv))) SWIG_fail;
  --argc;
  if ((argc >= 3) && (argc <= 4)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_ConvertPtr(argv[2], 0, SWIGTYPE_p_vrna_move_t, SWIG_POINTER_NO_NULL | 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_fold_compound_move_neighbor_diff__SWIG_0(self, argc, argv);
          }
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_fold_compound_move_neighbor_diff__SWIG_0(self, argc, argv);
          }
        }
      }
    }
  }
  if ((argc >= 4) && (argc <= 6)) {
    int _v = 0;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_vrna_fold_compound_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_var_arrayT_short_t, SWIG_POINTER_NO_NULL);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_vrna_move_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          _v = (argv[3] != 0);
          if (_v) {
            if (argc <= 4) {
              return _wrap_fold_compound_move_neighbor_diff__SWIG_1(self, argc, argv);
            }
            _v = (argv[4] != 0);
            if (_v) {
              if (argc <= 5) {
                return _wrap_fold_compound_move_neighbor_diff__SWIG_1(self, argc, argv);
              }
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_fold_compound_move_neighbor_diff__SWIG_1(self, argc, argv);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'fold_compound_move_neighbor_diff'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::move_neighbor_diff(var_array< short > &,vrna_move_t,var_array< vrna_move_t > *&,unsigned int)\n"
    "    vrna_fold_compound_t::move_neighbor_diff(var_array< short > &,vrna_move_t *,PyObject *,PyObject *,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_fold_compound_sc_multi_cb_add(PyObject *self, PyObject *args, PyObject *kwargs) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  PyObject *arg2 = 0 ;
  PyObject *arg3 = Py_None ;
  PyObject *arg4 = Py_None ;
  PyObject *arg5 = Py_None ;
  PyObject *arg6 = Py_None ;
  unsigned int arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  PyObject * obj0 = 0 ;
  PyObject * obj1 = 0 ;
  PyObject * obj2 = 0 ;
  PyObject * obj3 = 0 ;
  PyObject * obj4 = 0 ;
  PyObject * obj5 = 0 ;
  PyObject * obj6 = 0 ;
  char * kwnames[] = {
    (char *)"self",  (char *)"f",  (char *)"f_exp",  (char *)"data",  (char *)"data_prepare",  (char *)"data_free",  (char *)"decomp_type",  NULL 
  };
  unsigned int result;
  
  (void)self;
  if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|OOOOO:fold_compound_sc_multi_cb_add", kwnames, &obj0, &obj1, &obj2, &obj3, &obj4, &obj5, &obj6)) SWIG_fail;
  res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sc_multi_cb_add" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    arg2 = obj1;
  }
  if (obj2) {
    {
      arg3 = obj2;
    }
  }
  if (obj3) {
    {
      arg4 = obj3;
    }
  }
  if (obj4) {
    {
      arg5 = obj4;
    }
  }
  if (obj5) {
    {
      arg6 = obj5;
    }
  }
  if (obj6) {
    ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
    if (!SWIG_IsOK(ecode7)) {
      SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fold_compound_sc_multi_cb_add" "', argument " "7"" of type '" "unsigned int""'");
    } 
    arg7 = static_cast< unsigned int >(val7);
  }
  {
    try {
      result = (unsigned int)vrna_fold_compound_t_sc_multi_cb_add(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_fc_type_e result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_type_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (vrna_fc_type_e)(vrna_fc_type_e) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sequence_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  char *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sequence_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (char *) ((arg1)->sequence);
  resultobj = SWIG_FromCharPtr((const char *)result);
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_length_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (unsigned int) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_strands_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_strands_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (unsigned int) ((arg1)->strands);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_param_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_params_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (vrna_param_t *) ((arg1)->params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_param_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_params_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_exp_param_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_params_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (vrna_exp_param_t *) ((arg1)->exp_params);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_exp_param_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_matrices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_mx_mfe_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_matrices_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (vrna_mx_mfe_t *) ((arg1)->matrices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_exp_matrices_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_mx_pf_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_exp_matrices_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (vrna_mx_pf_t *) ((arg1)->exp_matrices);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_hc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_hc_t *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_hc_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  result = (vrna_hc_t *) ((arg1)->hc);
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_hc_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_strand_number_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_strand_number_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_fold_compound_t_strand_number_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_strand_order_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_strand_order_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_fold_compound_t_strand_order_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_strand_start_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_strand_start_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_fold_compound_t_strand_start_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_strand_end_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< unsigned int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_strand_end_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< unsigned int > *)vrna_fold_compound_t_strand_end_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_unsigned_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_iindx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_iindx_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_fold_compound_t_iindx_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_jindx_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_jindx_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_fold_compound_t_jindx_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sequence_encoding_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< short > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sequence_encoding_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< short > *)vrna_fold_compound_t_sequence_encoding_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound_sequence_encoding2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< short > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound_sequence_encoding2_get" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = (var_array< short > *)vrna_fold_compound_t_sequence_encoding2_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_short_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_fold_compound__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  vrna_md_t *arg2 = NULL ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  vrna_fold_compound_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_fold_compound" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_fold_compound" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_fold_compound" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (vrna_fold_compound_t *)new_vrna_fold_compound_t__SWIG_0((char const *)arg1,arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_fold_compound_t, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_fold_compound__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  std::vector< std::string,std::allocator< std::string > > arg1 ;
  vrna_md_t *arg2 = NULL ;
  unsigned int arg3 = VRNA_OPTION_DEFAULT ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  vrna_fold_compound_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 1) || (nobjs > 3)) SWIG_fail;
  {
    std::vector< std::string,std::allocator< std::string > > *ptr = (std::vector< std::string,std::allocator< std::string > > *)0;
    int res = swig::asptr(swig_obj[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_fold_compound" "', argument " "1"" of type '" "std::vector< std::string,std::allocator< std::string > >""'"); 
    }
    arg1 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  if (swig_obj[1]) {
    res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_fold_compound" "', argument " "2"" of type '" "vrna_md_t *""'"); 
    }
    arg2 = reinterpret_cast< vrna_md_t * >(argp2);
  }
  if (swig_obj[2]) {
    ecode3 = SWIG_AsVal_unsigned_SS_int(swig_obj[2], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_fold_compound" "', argument " "3"" of type '" "unsigned int""'");
    } 
    arg3 = static_cast< unsigned int >(val3);
  }
  {
    try {
      result = (vrna_fold_compound_t *)new_vrna_fold_compound_t__SWIG_1(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_fold_compound_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_fold_compound__SWIG_2(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
  PyObject *resultobj = 0;
  char *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  vrna_md_t *arg4 = NULL ;
  unsigned int arg5 = VRNA_OPTION_DEFAULT ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  vrna_fold_compound_t *result = 0 ;
  
  (void)self;
  if ((nobjs < 3) || (nobjs > 5)) SWIG_fail;
  res1 = SWIG_AsCharPtrAndSize(swig_obj[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_fold_compound" "', argument " "1"" of type '" "char const *""'");
  }
  arg1 = reinterpret_cast< char * >(buf1);
  res2 = SWIG_AsCharPtrAndSize(swig_obj[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_fold_compound" "', argument " "2"" of type '" "char *""'");
  }
  arg2 = reinterpret_cast< char * >(buf2);
  res3 = SWIG_AsCharPtrAndSize(swig_obj[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_fold_compound" "', argument " "3"" of type '" "char *""'");
  }
  arg3 = reinterpret_cast< char * >(buf3);
  if (swig_obj[3]) {
    res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_vrna_md_t, 0 |  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_fold_compound" "', argument " "4"" of type '" "vrna_md_t *""'"); 
    }
    arg4 = reinterpret_cast< vrna_md_t * >(argp4);
  }
  if (swig_obj[4]) {
    ecode5 = SWIG_AsVal_unsigned_SS_int(swig_obj[4], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_fold_compound" "', argument " "5"" of type '" "unsigned int""'");
    } 
    arg5 = static_cast< unsigned int >(val5);
  }
  {
    try {
      result = (vrna_fold_compound_t *)new_vrna_fold_compound_t__SWIG_2((char const *)arg1,arg2,arg3,arg4,arg5);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_fold_compound_t, SWIG_POINTER_NEW |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return resultobj;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_fold_compound(PyObject *self, PyObject *args) {
  Py_ssize_t argc;
  PyObject *argv[6] = {
    0
  };
  
  if (!(argc = SWIG_Python_UnpackTuple(args, "new_fold_compound", 0, 5, argv))) SWIG_fail;
  --argc;
  if ((argc >= 1) && (argc <= 3)) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_fold_compound__SWIG_0(self, argc, argv);
      }
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vrna_md_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_fold_compound__SWIG_0(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_fold_compound__SWIG_0(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 1) && (argc <= 3)) {
    int _v = 0;
    int res = swig::asptr(argv[0], (std::vector< std::string,std::allocator< std::string > >**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      if (argc <= 1) {
        return _wrap_new_fold_compound__SWIG_1(self, argc, argv);
      }
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_vrna_md_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        if (argc <= 2) {
          return _wrap_new_fold_compound__SWIG_1(self, argc, argv);
        }
        {
          int res = SWIG_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_fold_compound__SWIG_1(self, argc, argv);
        }
      }
    }
  }
  if ((argc >= 3) && (argc <= 5)) {
    int _v = 0;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          if (argc <= 3) {
            return _wrap_new_fold_compound__SWIG_2(self, argc, argv);
          }
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_vrna_md_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            if (argc <= 4) {
              return _wrap_new_fold_compound__SWIG_2(self, argc, argv);
            }
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_fold_compound__SWIG_2(self, argc, argv);
            }
          }
        }
      }
    }
  }
  
fail:
  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_fold_compound'.\n"
    "  Possible C/C++ prototypes are:\n"
    "    vrna_fold_compound_t::vrna_fold_compound_t(char const *,vrna_md_t *,unsigned int)\n"
    "    vrna_fold_compound_t::vrna_fold_compound_t(std::vector< std::string,std::allocator< std::string > >,vrna_md_t *,unsigned int)\n"
    "    vrna_fold_compound_t::vrna_fold_compound_t(char const *,char *,char *,vrna_md_t *,unsigned int)\n");
  return 0;
}


SWIGINTERN PyObject *_wrap_delete_fold_compound(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fold_compound" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      delete_vrna_fold_compound_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fold_compound___str__(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_fold_compound_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  std::string result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_fold_compound_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fold_compound___str__" "', argument " "1"" of type '" "vrna_fold_compound_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_fold_compound_t * >(argp1);
  {
    try {
      result = vrna_fold_compound_t___str__(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_std_string(static_cast< std::string >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *fold_compound_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_fold_compound_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *fold_compound_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_mx_mfe_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_mx_type_e result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_type_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  result = (vrna_mx_type_e)(vrna_mx_type_e) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_length_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  result = (unsigned int) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_strands_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_strands_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  result = (unsigned int) ((arg1)->strands);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_f5_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_f5_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_mx_mfe_t_f5_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_f3_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_f3_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_mx_mfe_t_f3_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_c_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_c_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_mx_mfe_t_c_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_fML_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_fML_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_mx_mfe_t_fML_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_fM1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_fM1_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_mx_mfe_t_fM1_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_fM2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< int > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_fM2_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (var_array< int > *)vrna_mx_mfe_t_fM2_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_int_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_Fc_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_Fc_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (int)vrna_mx_mfe_t_Fc_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_FcH_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_FcH_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (int)vrna_mx_mfe_t_FcH_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_FcI_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_FcI_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (int)vrna_mx_mfe_t_FcI_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_mfe_FcM_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_mfe_FcM_get" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      result = (int)vrna_mx_mfe_t_FcM_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_mx_mfe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_mx_mfe", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_mx_mfe_t *)new_vrna_mx_mfe_t();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_mx_mfe_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_mx_mfe(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_mfe_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_mfe_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mx_mfe" "', argument " "1"" of type '" "vrna_mx_mfe_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_mfe_t * >(argp1);
  {
    try {
      delete_vrna_mx_mfe_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *mx_mfe_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_mx_mfe_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mx_mfe_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN PyObject *_wrap_mx_pf_type_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  vrna_mx_type_e result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_type_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  result = (vrna_mx_type_e)(vrna_mx_type_e) ((arg1)->type);
  resultobj = SWIG_From_int(static_cast< int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_length_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  unsigned int result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_length_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  result = (unsigned int) ((arg1)->length);
  resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_scale_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_scale_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_scale_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_expMLbase_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_expMLbase_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_expMLbase_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_q_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_q_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_q_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qb_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qb_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_qb_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qm_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qm_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_qm_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qm1_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qm1_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_qm1_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_probs_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_probs_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_probs_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_q1k_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_q1k_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_q1k_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qln_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qln_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_qln_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FLT_OR_DBL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qo_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (FLT_OR_DBL)vrna_mx_pf_t_qo_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qm2_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  var_array< FLT_OR_DBL > *result = 0 ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qm2_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (var_array< FLT_OR_DBL > *)vrna_mx_pf_t_qm2_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_var_arrayT_FLT_OR_DBL_t, 0 |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qho_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FLT_OR_DBL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qho_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (FLT_OR_DBL)vrna_mx_pf_t_qho_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qio_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FLT_OR_DBL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qio_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (FLT_OR_DBL)vrna_mx_pf_t_qio_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mx_pf_qmo_get(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  FLT_OR_DBL result;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mx_pf_qmo_get" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      result = (FLT_OR_DBL)vrna_mx_pf_t_qmo_get(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_From_double(static_cast< double >(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_new_mx_pf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *result = 0 ;
  
  (void)self;
  if (!SWIG_Python_UnpackTuple(args, "new_mx_pf", 0, 0, 0)) SWIG_fail;
  {
    try {
      result = (vrna_mx_pf_t *)new_vrna_mx_pf_t();
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_vrna_mx_pf_t, SWIG_POINTER_NEW |  0 );
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_delete_mx_pf(PyObject *self, PyObject *args) {
  PyObject *resultobj = 0;
  vrna_mx_pf_t *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  PyObject *swig_obj[1] ;
  
  (void)self;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_vrna_mx_pf_t, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mx_pf" "', argument " "1"" of type '" "vrna_mx_pf_t *""'"); 
  }
  arg1 = reinterpret_cast< vrna_mx_pf_t * >(argp1);
  {
    try {
      delete_vrna_mx_pf_t(arg1);
    } catch (const std::exception& e) {
      SWIG_exception(SWIG_RuntimeError, e.what());
    }
  }
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *mx_pf_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *obj = NULL;
  if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
  SWIG_TypeNewClientData(SWIGTYPE_p_vrna_mx_pf_t, SWIG_NewClientData(obj));
  return SWIG_Py_Void();
}

SWIGINTERN PyObject *mx_pf_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  return SWIG_Python_InitShadowInstance(args);
}

SWIGINTERN int Swig_var_parameter_set_dna_mathews1999_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_dna_mathews1999 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_dna_mathews1999_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_dna_mathews1999, parameter_set_dna_mathews1999 + sizeof (parameter_set_dna_mathews1999) / sizeof (parameter_set_dna_mathews1999[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_dna_mathews2004_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_dna_mathews2004 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_dna_mathews2004_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_dna_mathews2004, parameter_set_dna_mathews2004 + sizeof (parameter_set_dna_mathews2004) / sizeof (parameter_set_dna_mathews2004[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_andronescu2007_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_andronescu2007 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_andronescu2007_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_andronescu2007, parameter_set_rna_andronescu2007 + sizeof (parameter_set_rna_andronescu2007) / sizeof (parameter_set_rna_andronescu2007[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_langdon2018_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_langdon2018 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_langdon2018_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_langdon2018, parameter_set_rna_langdon2018 + sizeof (parameter_set_rna_langdon2018) / sizeof (parameter_set_rna_langdon2018[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_misc_special_hairpins_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_misc_special_hairpins is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_misc_special_hairpins_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_misc_special_hairpins, parameter_set_rna_misc_special_hairpins + sizeof (parameter_set_rna_misc_special_hairpins) / sizeof (parameter_set_rna_misc_special_hairpins[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_turner1999_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_turner1999 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_turner1999_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_turner1999, parameter_set_rna_turner1999 + sizeof (parameter_set_rna_turner1999) / sizeof (parameter_set_rna_turner1999[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_turner2004_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_turner2004 is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_turner2004_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_turner2004, parameter_set_rna_turner2004 + sizeof (parameter_set_rna_turner2004) / sizeof (parameter_set_rna_turner2004[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_mod_7DA_parameters_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_mod_7DA_parameters is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_mod_7DA_parameters_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_mod_7DA_parameters, parameter_set_rna_mod_7DA_parameters + sizeof (parameter_set_rna_mod_7DA_parameters) / sizeof (parameter_set_rna_mod_7DA_parameters[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_mod_inosine_parameters_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_mod_inosine_parameters is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_mod_inosine_parameters_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_mod_inosine_parameters, parameter_set_rna_mod_inosine_parameters + sizeof (parameter_set_rna_mod_inosine_parameters) / sizeof (parameter_set_rna_mod_inosine_parameters[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_mod_m6A_parameters_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_mod_m6A_parameters is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_mod_m6A_parameters_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_mod_m6A_parameters, parameter_set_rna_mod_m6A_parameters + sizeof (parameter_set_rna_mod_m6A_parameters) / sizeof (parameter_set_rna_mod_m6A_parameters[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_mod_pseudouridine_parameters_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_mod_pseudouridine_parameters is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_mod_pseudouridine_parameters_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_mod_pseudouridine_parameters, parameter_set_rna_mod_pseudouridine_parameters + sizeof (parameter_set_rna_mod_pseudouridine_parameters) / sizeof (parameter_set_rna_mod_pseudouridine_parameters[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_mod_purine_parameters_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_mod_purine_parameters is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_mod_purine_parameters_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_mod_purine_parameters, parameter_set_rna_mod_purine_parameters + sizeof (parameter_set_rna_mod_purine_parameters) / sizeof (parameter_set_rna_mod_purine_parameters[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_parameter_set_rna_mod_dihydrouridine_parameters_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable parameter_set_rna_mod_dihydrouridine_parameters is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_parameter_set_rna_mod_dihydrouridine_parameters_get(void) {
  PyObject *pyobj = 0;
  
  {
    std::string str( parameter_set_rna_mod_dihydrouridine_parameters, parameter_set_rna_mod_dihydrouridine_parameters + sizeof (parameter_set_rna_mod_dihydrouridine_parameters) / sizeof (parameter_set_rna_mod_dihydrouridine_parameters[0]) );
    pyobj = PyUnicode_FromString(str.c_str());
  }
  return pyobj;
}


SWIGINTERN int Swig_var_probing_data_prior_probing_1M7_paired_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable probing_data_prior_probing_1M7_paired is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_probing_data_prior_probing_1M7_paired_get(void) {
  PyObject *pyobj = 0;
  
  {
    /* create string from data */
    std::string str( probing_data_prior_probing_1M7_paired, probing_data_prior_probing_1M7_paired + sizeof (probing_data_prior_probing_1M7_paired) / sizeof (probing_data_prior_probing_1M7_paired[0]) );
    pyobj = vrna_string_to_double_tuple(str);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_probing_data_prior_probing_1M7_unpaired_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable probing_data_prior_probing_1M7_unpaired is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_probing_data_prior_probing_1M7_unpaired_get(void) {
  PyObject *pyobj = 0;
  
  {
    /* create string from data */
    std::string str( probing_data_prior_probing_1M7_unpaired, probing_data_prior_probing_1M7_unpaired + sizeof (probing_data_prior_probing_1M7_unpaired) / sizeof (probing_data_prior_probing_1M7_unpaired[0]) );
    pyobj = vrna_string_to_double_tuple(str);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_probing_data_prior_probing_DMS_paired_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable probing_data_prior_probing_DMS_paired is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_probing_data_prior_probing_DMS_paired_get(void) {
  PyObject *pyobj = 0;
  
  {
    /* create string from data */
    std::string str( probing_data_prior_probing_DMS_paired, probing_data_prior_probing_DMS_paired + sizeof (probing_data_prior_probing_DMS_paired) / sizeof (probing_data_prior_probing_DMS_paired[0]) );
    pyobj = vrna_string_to_double_tuple(str);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_probing_data_prior_probing_DMS_unpaired_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable probing_data_prior_probing_DMS_unpaired is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_probing_data_prior_probing_DMS_unpaired_get(void) {
  PyObject *pyobj = 0;
  
  {
    /* create string from data */
    std::string str( probing_data_prior_probing_DMS_unpaired, probing_data_prior_probing_DMS_unpaired + sizeof (probing_data_prior_probing_DMS_unpaired) / sizeof (probing_data_prior_probing_DMS_unpaired[0]) );
    pyobj = vrna_string_to_double_tuple(str);
  }
  return pyobj;
}


SWIGINTERN int Swig_var_base_pair_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable base_pair is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_base_pair_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(base_pair), SWIGTYPE_p_vrna_bp_stack_t,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_pr_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable pr is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_pr_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(pr), SWIGTYPE_p_double,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_iindx_set(PyObject *) {
  SWIG_Error(SWIG_AttributeError,"Variable iindx is read-only.");
  return 1;
}


SWIGINTERN PyObject *Swig_var_iindx_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(iindx), SWIGTYPE_p_int,  0 );
  return pyobj;
}


SWIGINTERN int Swig_var_fold_constrained_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""fold_constrained""' of type '""int""'");
    }
    fold_constrained = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_fold_constrained_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(fold_constrained));
  return pyobj;
}


SWIGINTERN int Swig_var_csv_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""csv""' of type '""int""'");
    }
    csv = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_csv_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(csv));
  return pyobj;
}


SWIGINTERN int Swig_var_RibosumFile_set(PyObject *_val) {
  {
    char *cptr = 0; size_t csize = 0; int alloc = SWIG_NEWOBJ;
    int res = SWIG_AsCharPtrAndSize(_val, &cptr, &csize, &alloc);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""RibosumFile""' of type '""char *""'");
    }
    delete[] RibosumFile;
    if (alloc == SWIG_NEWOBJ) {
      RibosumFile = cptr;
    } else {
      RibosumFile = csize ? (char *)reinterpret_cast< char* >(memcpy(new char[csize], cptr, sizeof(char)*(csize))) : 0;
    }
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_RibosumFile_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_FromCharPtr(RibosumFile);
  return pyobj;
}


SWIGINTERN int Swig_var_james_rule_set(PyObject *_val) {
  {
    int val;
    int res = SWIG_AsVal_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""james_rule""' of type '""int""'");
    }
    james_rule = static_cast< int >(val);
  }
  return 0;
fail:
  return 1;
}


SWIGINTERN PyObject *Swig_var_james_rule_get(void) {
  PyObject *pyobj = 0;
  
  pyobj = SWIG_From_int(static_cast< int >(james_rule));
  return pyobj;
}


static PyMethodDef SwigMethods[] = {
	 { "new_intP", (PyCFunction)(void(*)(void))_wrap_new_intP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_intP", (PyCFunction)(void(*)(void))_wrap_delete_intP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "intP_getitem", (PyCFunction)(void(*)(void))_wrap_intP_getitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "intP_setitem", (PyCFunction)(void(*)(void))_wrap_intP_setitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "new_intArray", (PyCFunction)(void(*)(void))_wrap_new_intArray, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_intArray", _wrap_delete_intArray, METH_O, NULL},
	 { "intArray___getitem__", (PyCFunction)(void(*)(void))_wrap_intArray___getitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "intArray___setitem__", (PyCFunction)(void(*)(void))_wrap_intArray___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "intArray_cast", _wrap_intArray_cast, METH_O, NULL},
	 { "intArray_frompointer", (PyCFunction)(void(*)(void))_wrap_intArray_frompointer, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "intArray_swigregister", intArray_swigregister, METH_O, NULL},
	 { "intArray_swiginit", intArray_swiginit, METH_VARARGS, NULL},
	 { "new_floatP", (PyCFunction)(void(*)(void))_wrap_new_floatP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_floatP", (PyCFunction)(void(*)(void))_wrap_delete_floatP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "floatP_getitem", (PyCFunction)(void(*)(void))_wrap_floatP_getitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "floatP_setitem", (PyCFunction)(void(*)(void))_wrap_floatP_setitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "new_floatArray", (PyCFunction)(void(*)(void))_wrap_new_floatArray, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_floatArray", _wrap_delete_floatArray, METH_O, NULL},
	 { "floatArray___getitem__", (PyCFunction)(void(*)(void))_wrap_floatArray___getitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "floatArray___setitem__", (PyCFunction)(void(*)(void))_wrap_floatArray___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "floatArray_cast", _wrap_floatArray_cast, METH_O, NULL},
	 { "floatArray_frompointer", (PyCFunction)(void(*)(void))_wrap_floatArray_frompointer, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "floatArray_swigregister", floatArray_swigregister, METH_O, NULL},
	 { "floatArray_swiginit", floatArray_swiginit, METH_VARARGS, NULL},
	 { "new_doubleP", (PyCFunction)(void(*)(void))_wrap_new_doubleP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_doubleP", (PyCFunction)(void(*)(void))_wrap_delete_doubleP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "doubleP_getitem", (PyCFunction)(void(*)(void))_wrap_doubleP_getitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "doubleP_setitem", (PyCFunction)(void(*)(void))_wrap_doubleP_setitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "new_doubleArray", (PyCFunction)(void(*)(void))_wrap_new_doubleArray, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_doubleArray", _wrap_delete_doubleArray, METH_O, NULL},
	 { "doubleArray___getitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___getitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "doubleArray___setitem__", (PyCFunction)(void(*)(void))_wrap_doubleArray___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "doubleArray_cast", _wrap_doubleArray_cast, METH_O, NULL},
	 { "doubleArray_frompointer", (PyCFunction)(void(*)(void))_wrap_doubleArray_frompointer, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "doubleArray_swigregister", doubleArray_swigregister, METH_O, NULL},
	 { "doubleArray_swiginit", doubleArray_swiginit, METH_VARARGS, NULL},
	 { "new_ushortP", (PyCFunction)(void(*)(void))_wrap_new_ushortP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_ushortP", (PyCFunction)(void(*)(void))_wrap_delete_ushortP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ushortP_getitem", (PyCFunction)(void(*)(void))_wrap_ushortP_getitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ushortP_setitem", (PyCFunction)(void(*)(void))_wrap_ushortP_setitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "new_shortP", (PyCFunction)(void(*)(void))_wrap_new_shortP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_shortP", (PyCFunction)(void(*)(void))_wrap_delete_shortP, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "shortP_getitem", (PyCFunction)(void(*)(void))_wrap_shortP_getitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "shortP_setitem", (PyCFunction)(void(*)(void))_wrap_shortP_setitem, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "cdata", (PyCFunction)(void(*)(void))_wrap_cdata, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "memmove", (PyCFunction)(void(*)(void))_wrap_memmove, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_SwigPyIterator", _wrap_delete_SwigPyIterator, METH_O, NULL},
	 { "SwigPyIterator_value", _wrap_SwigPyIterator_value, METH_O, NULL},
	 { "SwigPyIterator_incr", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator_incr, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator_decr", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator_decr, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator_distance", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator_distance, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator_equal", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator_equal, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator_copy", _wrap_SwigPyIterator_copy, METH_O, NULL},
	 { "SwigPyIterator_next", _wrap_SwigPyIterator_next, METH_O, NULL},
	 { "SwigPyIterator___next__", _wrap_SwigPyIterator___next__, METH_O, NULL},
	 { "SwigPyIterator_previous", _wrap_SwigPyIterator_previous, METH_O, NULL},
	 { "SwigPyIterator_advance", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator_advance, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator___eq__", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator___eq__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator___ne__", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator___ne__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator___iadd__", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator___iadd__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator___isub__", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator___isub__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator___add__", (PyCFunction)(void(*)(void))_wrap_SwigPyIterator___add__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SwigPyIterator___sub__", _wrap_SwigPyIterator___sub__, METH_VARARGS, NULL},
	 { "SwigPyIterator_swigregister", SwigPyIterator_swigregister, METH_O, NULL},
	 { "new_DoublePair", _wrap_new_DoublePair, METH_VARARGS, NULL},
	 { "DoublePair_first_set", _wrap_DoublePair_first_set, METH_VARARGS, NULL},
	 { "DoublePair_first_get", _wrap_DoublePair_first_get, METH_O, NULL},
	 { "DoublePair_second_set", _wrap_DoublePair_second_set, METH_VARARGS, NULL},
	 { "DoublePair_second_get", _wrap_DoublePair_second_get, METH_O, NULL},
	 { "delete_DoublePair", _wrap_delete_DoublePair, METH_O, NULL},
	 { "DoublePair_swigregister", DoublePair_swigregister, METH_O, NULL},
	 { "DoublePair_swiginit", DoublePair_swiginit, METH_VARARGS, NULL},
	 { "IntVector_iterator", _wrap_IntVector_iterator, METH_O, NULL},
	 { "IntVector___nonzero__", _wrap_IntVector___nonzero__, METH_O, NULL},
	 { "IntVector___bool__", _wrap_IntVector___bool__, METH_O, NULL},
	 { "IntVector___len__", _wrap_IntVector___len__, METH_O, NULL},
	 { "IntVector___getslice__", (PyCFunction)(void(*)(void))_wrap_IntVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntVector___setslice__", _wrap_IntVector___setslice__, METH_VARARGS, NULL},
	 { "IntVector___delslice__", (PyCFunction)(void(*)(void))_wrap_IntVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntVector___delitem__", _wrap_IntVector___delitem__, METH_VARARGS, NULL},
	 { "IntVector___getitem__", _wrap_IntVector___getitem__, METH_VARARGS, NULL},
	 { "IntVector___setitem__", _wrap_IntVector___setitem__, METH_VARARGS, NULL},
	 { "IntVector_pop", _wrap_IntVector_pop, METH_O, NULL},
	 { "IntVector_append", (PyCFunction)(void(*)(void))_wrap_IntVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntVector_empty", _wrap_IntVector_empty, METH_O, NULL},
	 { "IntVector_size", _wrap_IntVector_size, METH_O, NULL},
	 { "IntVector_swap", (PyCFunction)(void(*)(void))_wrap_IntVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntVector_begin", _wrap_IntVector_begin, METH_O, NULL},
	 { "IntVector_end", _wrap_IntVector_end, METH_O, NULL},
	 { "IntVector_rbegin", _wrap_IntVector_rbegin, METH_O, NULL},
	 { "IntVector_rend", _wrap_IntVector_rend, METH_O, NULL},
	 { "IntVector_clear", _wrap_IntVector_clear, METH_O, NULL},
	 { "IntVector_get_allocator", _wrap_IntVector_get_allocator, METH_O, NULL},
	 { "IntVector_pop_back", _wrap_IntVector_pop_back, METH_O, NULL},
	 { "IntVector_erase", _wrap_IntVector_erase, METH_VARARGS, NULL},
	 { "new_IntVector", _wrap_new_IntVector, METH_VARARGS, NULL},
	 { "IntVector_push_back", (PyCFunction)(void(*)(void))_wrap_IntVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntVector_front", _wrap_IntVector_front, METH_O, NULL},
	 { "IntVector_back", _wrap_IntVector_back, METH_O, NULL},
	 { "IntVector_assign", (PyCFunction)(void(*)(void))_wrap_IntVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntVector_resize", _wrap_IntVector_resize, METH_VARARGS, NULL},
	 { "IntVector_insert", _wrap_IntVector_insert, METH_VARARGS, NULL},
	 { "IntVector_reserve", (PyCFunction)(void(*)(void))_wrap_IntVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntVector_capacity", _wrap_IntVector_capacity, METH_O, NULL},
	 { "delete_IntVector", _wrap_delete_IntVector, METH_O, NULL},
	 { "IntVector_swigregister", IntVector_swigregister, METH_O, NULL},
	 { "IntVector_swiginit", IntVector_swiginit, METH_VARARGS, NULL},
	 { "UIntVector_iterator", _wrap_UIntVector_iterator, METH_O, NULL},
	 { "UIntVector___nonzero__", _wrap_UIntVector___nonzero__, METH_O, NULL},
	 { "UIntVector___bool__", _wrap_UIntVector___bool__, METH_O, NULL},
	 { "UIntVector___len__", _wrap_UIntVector___len__, METH_O, NULL},
	 { "UIntVector___getslice__", (PyCFunction)(void(*)(void))_wrap_UIntVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntVector___setslice__", _wrap_UIntVector___setslice__, METH_VARARGS, NULL},
	 { "UIntVector___delslice__", (PyCFunction)(void(*)(void))_wrap_UIntVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntVector___delitem__", _wrap_UIntVector___delitem__, METH_VARARGS, NULL},
	 { "UIntVector___getitem__", _wrap_UIntVector___getitem__, METH_VARARGS, NULL},
	 { "UIntVector___setitem__", _wrap_UIntVector___setitem__, METH_VARARGS, NULL},
	 { "UIntVector_pop", _wrap_UIntVector_pop, METH_O, NULL},
	 { "UIntVector_append", (PyCFunction)(void(*)(void))_wrap_UIntVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntVector_empty", _wrap_UIntVector_empty, METH_O, NULL},
	 { "UIntVector_size", _wrap_UIntVector_size, METH_O, NULL},
	 { "UIntVector_swap", (PyCFunction)(void(*)(void))_wrap_UIntVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntVector_begin", _wrap_UIntVector_begin, METH_O, NULL},
	 { "UIntVector_end", _wrap_UIntVector_end, METH_O, NULL},
	 { "UIntVector_rbegin", _wrap_UIntVector_rbegin, METH_O, NULL},
	 { "UIntVector_rend", _wrap_UIntVector_rend, METH_O, NULL},
	 { "UIntVector_clear", _wrap_UIntVector_clear, METH_O, NULL},
	 { "UIntVector_get_allocator", _wrap_UIntVector_get_allocator, METH_O, NULL},
	 { "UIntVector_pop_back", _wrap_UIntVector_pop_back, METH_O, NULL},
	 { "UIntVector_erase", _wrap_UIntVector_erase, METH_VARARGS, NULL},
	 { "new_UIntVector", _wrap_new_UIntVector, METH_VARARGS, NULL},
	 { "UIntVector_push_back", (PyCFunction)(void(*)(void))_wrap_UIntVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntVector_front", _wrap_UIntVector_front, METH_O, NULL},
	 { "UIntVector_back", _wrap_UIntVector_back, METH_O, NULL},
	 { "UIntVector_assign", (PyCFunction)(void(*)(void))_wrap_UIntVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntVector_resize", _wrap_UIntVector_resize, METH_VARARGS, NULL},
	 { "UIntVector_insert", _wrap_UIntVector_insert, METH_VARARGS, NULL},
	 { "UIntVector_reserve", (PyCFunction)(void(*)(void))_wrap_UIntVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntVector_capacity", _wrap_UIntVector_capacity, METH_O, NULL},
	 { "delete_UIntVector", _wrap_delete_UIntVector, METH_O, NULL},
	 { "UIntVector_swigregister", UIntVector_swigregister, METH_O, NULL},
	 { "UIntVector_swiginit", UIntVector_swiginit, METH_VARARGS, NULL},
	 { "UIntUIntVector_iterator", _wrap_UIntUIntVector_iterator, METH_O, NULL},
	 { "UIntUIntVector___nonzero__", _wrap_UIntUIntVector___nonzero__, METH_O, NULL},
	 { "UIntUIntVector___bool__", _wrap_UIntUIntVector___bool__, METH_O, NULL},
	 { "UIntUIntVector___len__", _wrap_UIntUIntVector___len__, METH_O, NULL},
	 { "UIntUIntVector___getslice__", (PyCFunction)(void(*)(void))_wrap_UIntUIntVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntUIntVector___setslice__", _wrap_UIntUIntVector___setslice__, METH_VARARGS, NULL},
	 { "UIntUIntVector___delslice__", (PyCFunction)(void(*)(void))_wrap_UIntUIntVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntUIntVector___delitem__", _wrap_UIntUIntVector___delitem__, METH_VARARGS, NULL},
	 { "UIntUIntVector___getitem__", _wrap_UIntUIntVector___getitem__, METH_VARARGS, NULL},
	 { "UIntUIntVector___setitem__", _wrap_UIntUIntVector___setitem__, METH_VARARGS, NULL},
	 { "UIntUIntVector_pop", _wrap_UIntUIntVector_pop, METH_O, NULL},
	 { "UIntUIntVector_append", (PyCFunction)(void(*)(void))_wrap_UIntUIntVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntUIntVector_empty", _wrap_UIntUIntVector_empty, METH_O, NULL},
	 { "UIntUIntVector_size", _wrap_UIntUIntVector_size, METH_O, NULL},
	 { "UIntUIntVector_swap", (PyCFunction)(void(*)(void))_wrap_UIntUIntVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntUIntVector_begin", _wrap_UIntUIntVector_begin, METH_O, NULL},
	 { "UIntUIntVector_end", _wrap_UIntUIntVector_end, METH_O, NULL},
	 { "UIntUIntVector_rbegin", _wrap_UIntUIntVector_rbegin, METH_O, NULL},
	 { "UIntUIntVector_rend", _wrap_UIntUIntVector_rend, METH_O, NULL},
	 { "UIntUIntVector_clear", _wrap_UIntUIntVector_clear, METH_O, NULL},
	 { "UIntUIntVector_get_allocator", _wrap_UIntUIntVector_get_allocator, METH_O, NULL},
	 { "UIntUIntVector_pop_back", _wrap_UIntUIntVector_pop_back, METH_O, NULL},
	 { "UIntUIntVector_erase", _wrap_UIntUIntVector_erase, METH_VARARGS, NULL},
	 { "new_UIntUIntVector", _wrap_new_UIntUIntVector, METH_VARARGS, NULL},
	 { "UIntUIntVector_push_back", (PyCFunction)(void(*)(void))_wrap_UIntUIntVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntUIntVector_front", _wrap_UIntUIntVector_front, METH_O, NULL},
	 { "UIntUIntVector_back", _wrap_UIntUIntVector_back, METH_O, NULL},
	 { "UIntUIntVector_assign", (PyCFunction)(void(*)(void))_wrap_UIntUIntVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntUIntVector_resize", _wrap_UIntUIntVector_resize, METH_VARARGS, NULL},
	 { "UIntUIntVector_insert", _wrap_UIntUIntVector_insert, METH_VARARGS, NULL},
	 { "UIntUIntVector_reserve", (PyCFunction)(void(*)(void))_wrap_UIntUIntVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "UIntUIntVector_capacity", _wrap_UIntUIntVector_capacity, METH_O, NULL},
	 { "delete_UIntUIntVector", _wrap_delete_UIntUIntVector, METH_O, NULL},
	 { "UIntUIntVector_swigregister", UIntUIntVector_swigregister, METH_O, NULL},
	 { "UIntUIntVector_swiginit", UIntUIntVector_swiginit, METH_VARARGS, NULL},
	 { "DoubleVector_iterator", _wrap_DoubleVector_iterator, METH_O, NULL},
	 { "DoubleVector___nonzero__", _wrap_DoubleVector___nonzero__, METH_O, NULL},
	 { "DoubleVector___bool__", _wrap_DoubleVector___bool__, METH_O, NULL},
	 { "DoubleVector___len__", _wrap_DoubleVector___len__, METH_O, NULL},
	 { "DoubleVector___getslice__", (PyCFunction)(void(*)(void))_wrap_DoubleVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleVector___setslice__", _wrap_DoubleVector___setslice__, METH_VARARGS, NULL},
	 { "DoubleVector___delslice__", (PyCFunction)(void(*)(void))_wrap_DoubleVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleVector___delitem__", _wrap_DoubleVector___delitem__, METH_VARARGS, NULL},
	 { "DoubleVector___getitem__", _wrap_DoubleVector___getitem__, METH_VARARGS, NULL},
	 { "DoubleVector___setitem__", _wrap_DoubleVector___setitem__, METH_VARARGS, NULL},
	 { "DoubleVector_pop", _wrap_DoubleVector_pop, METH_O, NULL},
	 { "DoubleVector_append", (PyCFunction)(void(*)(void))_wrap_DoubleVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleVector_empty", _wrap_DoubleVector_empty, METH_O, NULL},
	 { "DoubleVector_size", _wrap_DoubleVector_size, METH_O, NULL},
	 { "DoubleVector_swap", (PyCFunction)(void(*)(void))_wrap_DoubleVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleVector_begin", _wrap_DoubleVector_begin, METH_O, NULL},
	 { "DoubleVector_end", _wrap_DoubleVector_end, METH_O, NULL},
	 { "DoubleVector_rbegin", _wrap_DoubleVector_rbegin, METH_O, NULL},
	 { "DoubleVector_rend", _wrap_DoubleVector_rend, METH_O, NULL},
	 { "DoubleVector_clear", _wrap_DoubleVector_clear, METH_O, NULL},
	 { "DoubleVector_get_allocator", _wrap_DoubleVector_get_allocator, METH_O, NULL},
	 { "DoubleVector_pop_back", _wrap_DoubleVector_pop_back, METH_O, NULL},
	 { "DoubleVector_erase", _wrap_DoubleVector_erase, METH_VARARGS, NULL},
	 { "new_DoubleVector", _wrap_new_DoubleVector, METH_VARARGS, NULL},
	 { "DoubleVector_push_back", (PyCFunction)(void(*)(void))_wrap_DoubleVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleVector_front", _wrap_DoubleVector_front, METH_O, NULL},
	 { "DoubleVector_back", _wrap_DoubleVector_back, METH_O, NULL},
	 { "DoubleVector_assign", (PyCFunction)(void(*)(void))_wrap_DoubleVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleVector_resize", _wrap_DoubleVector_resize, METH_VARARGS, NULL},
	 { "DoubleVector_insert", _wrap_DoubleVector_insert, METH_VARARGS, NULL},
	 { "DoubleVector_reserve", (PyCFunction)(void(*)(void))_wrap_DoubleVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleVector_capacity", _wrap_DoubleVector_capacity, METH_O, NULL},
	 { "delete_DoubleVector", _wrap_delete_DoubleVector, METH_O, NULL},
	 { "DoubleVector_swigregister", DoubleVector_swigregister, METH_O, NULL},
	 { "DoubleVector_swiginit", DoubleVector_swiginit, METH_VARARGS, NULL},
	 { "StringVector_iterator", _wrap_StringVector_iterator, METH_O, NULL},
	 { "StringVector___nonzero__", _wrap_StringVector___nonzero__, METH_O, NULL},
	 { "StringVector___bool__", _wrap_StringVector___bool__, METH_O, NULL},
	 { "StringVector___len__", _wrap_StringVector___len__, METH_O, NULL},
	 { "StringVector___getslice__", (PyCFunction)(void(*)(void))_wrap_StringVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "StringVector___setslice__", _wrap_StringVector___setslice__, METH_VARARGS, NULL},
	 { "StringVector___delslice__", (PyCFunction)(void(*)(void))_wrap_StringVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "StringVector___delitem__", _wrap_StringVector___delitem__, METH_VARARGS, NULL},
	 { "StringVector___getitem__", _wrap_StringVector___getitem__, METH_VARARGS, NULL},
	 { "StringVector___setitem__", _wrap_StringVector___setitem__, METH_VARARGS, NULL},
	 { "StringVector_pop", _wrap_StringVector_pop, METH_O, NULL},
	 { "StringVector_append", (PyCFunction)(void(*)(void))_wrap_StringVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "StringVector_empty", _wrap_StringVector_empty, METH_O, NULL},
	 { "StringVector_size", _wrap_StringVector_size, METH_O, NULL},
	 { "StringVector_swap", (PyCFunction)(void(*)(void))_wrap_StringVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "StringVector_begin", _wrap_StringVector_begin, METH_O, NULL},
	 { "StringVector_end", _wrap_StringVector_end, METH_O, NULL},
	 { "StringVector_rbegin", _wrap_StringVector_rbegin, METH_O, NULL},
	 { "StringVector_rend", _wrap_StringVector_rend, METH_O, NULL},
	 { "StringVector_clear", _wrap_StringVector_clear, METH_O, NULL},
	 { "StringVector_get_allocator", _wrap_StringVector_get_allocator, METH_O, NULL},
	 { "StringVector_pop_back", _wrap_StringVector_pop_back, METH_O, NULL},
	 { "StringVector_erase", _wrap_StringVector_erase, METH_VARARGS, NULL},
	 { "new_StringVector", _wrap_new_StringVector, METH_VARARGS, NULL},
	 { "StringVector_push_back", (PyCFunction)(void(*)(void))_wrap_StringVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "StringVector_front", _wrap_StringVector_front, METH_O, NULL},
	 { "StringVector_back", _wrap_StringVector_back, METH_O, NULL},
	 { "StringVector_assign", (PyCFunction)(void(*)(void))_wrap_StringVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "StringVector_resize", _wrap_StringVector_resize, METH_VARARGS, NULL},
	 { "StringVector_insert", _wrap_StringVector_insert, METH_VARARGS, NULL},
	 { "StringVector_reserve", (PyCFunction)(void(*)(void))_wrap_StringVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "StringVector_capacity", _wrap_StringVector_capacity, METH_O, NULL},
	 { "delete_StringVector", _wrap_delete_StringVector, METH_O, NULL},
	 { "StringVector_swigregister", StringVector_swigregister, METH_O, NULL},
	 { "StringVector_swiginit", StringVector_swiginit, METH_VARARGS, NULL},
	 { "ConstCharVector_iterator", _wrap_ConstCharVector_iterator, METH_O, NULL},
	 { "ConstCharVector___nonzero__", _wrap_ConstCharVector___nonzero__, METH_O, NULL},
	 { "ConstCharVector___bool__", _wrap_ConstCharVector___bool__, METH_O, NULL},
	 { "ConstCharVector___len__", _wrap_ConstCharVector___len__, METH_O, NULL},
	 { "ConstCharVector___getslice__", (PyCFunction)(void(*)(void))_wrap_ConstCharVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ConstCharVector___setslice__", _wrap_ConstCharVector___setslice__, METH_VARARGS, NULL},
	 { "ConstCharVector___delslice__", (PyCFunction)(void(*)(void))_wrap_ConstCharVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ConstCharVector___delitem__", _wrap_ConstCharVector___delitem__, METH_VARARGS, NULL},
	 { "ConstCharVector___getitem__", _wrap_ConstCharVector___getitem__, METH_VARARGS, NULL},
	 { "ConstCharVector___setitem__", _wrap_ConstCharVector___setitem__, METH_VARARGS, NULL},
	 { "ConstCharVector_pop", _wrap_ConstCharVector_pop, METH_O, NULL},
	 { "ConstCharVector_append", (PyCFunction)(void(*)(void))_wrap_ConstCharVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ConstCharVector_empty", _wrap_ConstCharVector_empty, METH_O, NULL},
	 { "ConstCharVector_size", _wrap_ConstCharVector_size, METH_O, NULL},
	 { "ConstCharVector_swap", (PyCFunction)(void(*)(void))_wrap_ConstCharVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ConstCharVector_begin", _wrap_ConstCharVector_begin, METH_O, NULL},
	 { "ConstCharVector_end", _wrap_ConstCharVector_end, METH_O, NULL},
	 { "ConstCharVector_rbegin", _wrap_ConstCharVector_rbegin, METH_O, NULL},
	 { "ConstCharVector_rend", _wrap_ConstCharVector_rend, METH_O, NULL},
	 { "ConstCharVector_clear", _wrap_ConstCharVector_clear, METH_O, NULL},
	 { "ConstCharVector_get_allocator", _wrap_ConstCharVector_get_allocator, METH_O, NULL},
	 { "ConstCharVector_pop_back", _wrap_ConstCharVector_pop_back, METH_O, NULL},
	 { "ConstCharVector_erase", _wrap_ConstCharVector_erase, METH_VARARGS, NULL},
	 { "new_ConstCharVector", _wrap_new_ConstCharVector, METH_VARARGS, NULL},
	 { "ConstCharVector_push_back", (PyCFunction)(void(*)(void))_wrap_ConstCharVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ConstCharVector_front", _wrap_ConstCharVector_front, METH_O, NULL},
	 { "ConstCharVector_back", _wrap_ConstCharVector_back, METH_O, NULL},
	 { "ConstCharVector_assign", (PyCFunction)(void(*)(void))_wrap_ConstCharVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ConstCharVector_resize", _wrap_ConstCharVector_resize, METH_VARARGS, NULL},
	 { "ConstCharVector_insert", _wrap_ConstCharVector_insert, METH_VARARGS, NULL},
	 { "ConstCharVector_reserve", (PyCFunction)(void(*)(void))_wrap_ConstCharVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ConstCharVector_capacity", _wrap_ConstCharVector_capacity, METH_O, NULL},
	 { "delete_ConstCharVector", _wrap_delete_ConstCharVector, METH_O, NULL},
	 { "ConstCharVector_swigregister", ConstCharVector_swigregister, METH_O, NULL},
	 { "ConstCharVector_swiginit", ConstCharVector_swiginit, METH_VARARGS, NULL},
	 { "SOLUTIONVector_iterator", _wrap_SOLUTIONVector_iterator, METH_O, NULL},
	 { "SOLUTIONVector___nonzero__", _wrap_SOLUTIONVector___nonzero__, METH_O, NULL},
	 { "SOLUTIONVector___bool__", _wrap_SOLUTIONVector___bool__, METH_O, NULL},
	 { "SOLUTIONVector___len__", _wrap_SOLUTIONVector___len__, METH_O, NULL},
	 { "SOLUTIONVector___getslice__", (PyCFunction)(void(*)(void))_wrap_SOLUTIONVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTIONVector___setslice__", _wrap_SOLUTIONVector___setslice__, METH_VARARGS, NULL},
	 { "SOLUTIONVector___delslice__", (PyCFunction)(void(*)(void))_wrap_SOLUTIONVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTIONVector___delitem__", _wrap_SOLUTIONVector___delitem__, METH_VARARGS, NULL},
	 { "SOLUTIONVector___getitem__", _wrap_SOLUTIONVector___getitem__, METH_VARARGS, NULL},
	 { "SOLUTIONVector___setitem__", _wrap_SOLUTIONVector___setitem__, METH_VARARGS, NULL},
	 { "SOLUTIONVector_pop", _wrap_SOLUTIONVector_pop, METH_O, NULL},
	 { "SOLUTIONVector_append", (PyCFunction)(void(*)(void))_wrap_SOLUTIONVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTIONVector_empty", _wrap_SOLUTIONVector_empty, METH_O, NULL},
	 { "SOLUTIONVector_size", _wrap_SOLUTIONVector_size, METH_O, NULL},
	 { "SOLUTIONVector_swap", (PyCFunction)(void(*)(void))_wrap_SOLUTIONVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTIONVector_begin", _wrap_SOLUTIONVector_begin, METH_O, NULL},
	 { "SOLUTIONVector_end", _wrap_SOLUTIONVector_end, METH_O, NULL},
	 { "SOLUTIONVector_rbegin", _wrap_SOLUTIONVector_rbegin, METH_O, NULL},
	 { "SOLUTIONVector_rend", _wrap_SOLUTIONVector_rend, METH_O, NULL},
	 { "SOLUTIONVector_clear", _wrap_SOLUTIONVector_clear, METH_O, NULL},
	 { "SOLUTIONVector_get_allocator", _wrap_SOLUTIONVector_get_allocator, METH_O, NULL},
	 { "SOLUTIONVector_pop_back", _wrap_SOLUTIONVector_pop_back, METH_O, NULL},
	 { "SOLUTIONVector_erase", _wrap_SOLUTIONVector_erase, METH_VARARGS, NULL},
	 { "new_SOLUTIONVector", _wrap_new_SOLUTIONVector, METH_VARARGS, NULL},
	 { "SOLUTIONVector_push_back", (PyCFunction)(void(*)(void))_wrap_SOLUTIONVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTIONVector_front", _wrap_SOLUTIONVector_front, METH_O, NULL},
	 { "SOLUTIONVector_back", _wrap_SOLUTIONVector_back, METH_O, NULL},
	 { "SOLUTIONVector_assign", (PyCFunction)(void(*)(void))_wrap_SOLUTIONVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTIONVector_resize", _wrap_SOLUTIONVector_resize, METH_VARARGS, NULL},
	 { "SOLUTIONVector_insert", _wrap_SOLUTIONVector_insert, METH_VARARGS, NULL},
	 { "SOLUTIONVector_reserve", (PyCFunction)(void(*)(void))_wrap_SOLUTIONVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTIONVector_capacity", _wrap_SOLUTIONVector_capacity, METH_O, NULL},
	 { "delete_SOLUTIONVector", _wrap_delete_SOLUTIONVector, METH_O, NULL},
	 { "SOLUTIONVector_swigregister", SOLUTIONVector_swigregister, METH_O, NULL},
	 { "SOLUTIONVector_swiginit", SOLUTIONVector_swiginit, METH_VARARGS, NULL},
	 { "CoordinateVector_iterator", _wrap_CoordinateVector_iterator, METH_O, NULL},
	 { "CoordinateVector___nonzero__", _wrap_CoordinateVector___nonzero__, METH_O, NULL},
	 { "CoordinateVector___bool__", _wrap_CoordinateVector___bool__, METH_O, NULL},
	 { "CoordinateVector___len__", _wrap_CoordinateVector___len__, METH_O, NULL},
	 { "CoordinateVector___getslice__", (PyCFunction)(void(*)(void))_wrap_CoordinateVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CoordinateVector___setslice__", _wrap_CoordinateVector___setslice__, METH_VARARGS, NULL},
	 { "CoordinateVector___delslice__", (PyCFunction)(void(*)(void))_wrap_CoordinateVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CoordinateVector___delitem__", _wrap_CoordinateVector___delitem__, METH_VARARGS, NULL},
	 { "CoordinateVector___getitem__", _wrap_CoordinateVector___getitem__, METH_VARARGS, NULL},
	 { "CoordinateVector___setitem__", _wrap_CoordinateVector___setitem__, METH_VARARGS, NULL},
	 { "CoordinateVector_pop", _wrap_CoordinateVector_pop, METH_O, NULL},
	 { "CoordinateVector_append", (PyCFunction)(void(*)(void))_wrap_CoordinateVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CoordinateVector_empty", _wrap_CoordinateVector_empty, METH_O, NULL},
	 { "CoordinateVector_size", _wrap_CoordinateVector_size, METH_O, NULL},
	 { "CoordinateVector_swap", (PyCFunction)(void(*)(void))_wrap_CoordinateVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CoordinateVector_begin", _wrap_CoordinateVector_begin, METH_O, NULL},
	 { "CoordinateVector_end", _wrap_CoordinateVector_end, METH_O, NULL},
	 { "CoordinateVector_rbegin", _wrap_CoordinateVector_rbegin, METH_O, NULL},
	 { "CoordinateVector_rend", _wrap_CoordinateVector_rend, METH_O, NULL},
	 { "CoordinateVector_clear", _wrap_CoordinateVector_clear, METH_O, NULL},
	 { "CoordinateVector_get_allocator", _wrap_CoordinateVector_get_allocator, METH_O, NULL},
	 { "CoordinateVector_pop_back", _wrap_CoordinateVector_pop_back, METH_O, NULL},
	 { "CoordinateVector_erase", _wrap_CoordinateVector_erase, METH_VARARGS, NULL},
	 { "new_CoordinateVector", _wrap_new_CoordinateVector, METH_VARARGS, NULL},
	 { "CoordinateVector_push_back", (PyCFunction)(void(*)(void))_wrap_CoordinateVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CoordinateVector_front", _wrap_CoordinateVector_front, METH_O, NULL},
	 { "CoordinateVector_back", _wrap_CoordinateVector_back, METH_O, NULL},
	 { "CoordinateVector_assign", (PyCFunction)(void(*)(void))_wrap_CoordinateVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CoordinateVector_resize", _wrap_CoordinateVector_resize, METH_VARARGS, NULL},
	 { "CoordinateVector_insert", _wrap_CoordinateVector_insert, METH_VARARGS, NULL},
	 { "CoordinateVector_reserve", (PyCFunction)(void(*)(void))_wrap_CoordinateVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "CoordinateVector_capacity", _wrap_CoordinateVector_capacity, METH_O, NULL},
	 { "delete_CoordinateVector", _wrap_delete_CoordinateVector, METH_O, NULL},
	 { "CoordinateVector_swigregister", CoordinateVector_swigregister, METH_O, NULL},
	 { "CoordinateVector_swiginit", CoordinateVector_swiginit, METH_VARARGS, NULL},
	 { "DoubleDoubleVector_iterator", _wrap_DoubleDoubleVector_iterator, METH_O, NULL},
	 { "DoubleDoubleVector___nonzero__", _wrap_DoubleDoubleVector___nonzero__, METH_O, NULL},
	 { "DoubleDoubleVector___bool__", _wrap_DoubleDoubleVector___bool__, METH_O, NULL},
	 { "DoubleDoubleVector___len__", _wrap_DoubleDoubleVector___len__, METH_O, NULL},
	 { "DoubleDoubleVector___getslice__", (PyCFunction)(void(*)(void))_wrap_DoubleDoubleVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleDoubleVector___setslice__", _wrap_DoubleDoubleVector___setslice__, METH_VARARGS, NULL},
	 { "DoubleDoubleVector___delslice__", (PyCFunction)(void(*)(void))_wrap_DoubleDoubleVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleDoubleVector___delitem__", _wrap_DoubleDoubleVector___delitem__, METH_VARARGS, NULL},
	 { "DoubleDoubleVector___getitem__", _wrap_DoubleDoubleVector___getitem__, METH_VARARGS, NULL},
	 { "DoubleDoubleVector___setitem__", _wrap_DoubleDoubleVector___setitem__, METH_VARARGS, NULL},
	 { "DoubleDoubleVector_pop", _wrap_DoubleDoubleVector_pop, METH_O, NULL},
	 { "DoubleDoubleVector_append", (PyCFunction)(void(*)(void))_wrap_DoubleDoubleVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleDoubleVector_empty", _wrap_DoubleDoubleVector_empty, METH_O, NULL},
	 { "DoubleDoubleVector_size", _wrap_DoubleDoubleVector_size, METH_O, NULL},
	 { "DoubleDoubleVector_swap", (PyCFunction)(void(*)(void))_wrap_DoubleDoubleVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleDoubleVector_begin", _wrap_DoubleDoubleVector_begin, METH_O, NULL},
	 { "DoubleDoubleVector_end", _wrap_DoubleDoubleVector_end, METH_O, NULL},
	 { "DoubleDoubleVector_rbegin", _wrap_DoubleDoubleVector_rbegin, METH_O, NULL},
	 { "DoubleDoubleVector_rend", _wrap_DoubleDoubleVector_rend, METH_O, NULL},
	 { "DoubleDoubleVector_clear", _wrap_DoubleDoubleVector_clear, METH_O, NULL},
	 { "DoubleDoubleVector_get_allocator", _wrap_DoubleDoubleVector_get_allocator, METH_O, NULL},
	 { "DoubleDoubleVector_pop_back", _wrap_DoubleDoubleVector_pop_back, METH_O, NULL},
	 { "DoubleDoubleVector_erase", _wrap_DoubleDoubleVector_erase, METH_VARARGS, NULL},
	 { "new_DoubleDoubleVector", _wrap_new_DoubleDoubleVector, METH_VARARGS, NULL},
	 { "DoubleDoubleVector_push_back", (PyCFunction)(void(*)(void))_wrap_DoubleDoubleVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleDoubleVector_front", _wrap_DoubleDoubleVector_front, METH_O, NULL},
	 { "DoubleDoubleVector_back", _wrap_DoubleDoubleVector_back, METH_O, NULL},
	 { "DoubleDoubleVector_assign", (PyCFunction)(void(*)(void))_wrap_DoubleDoubleVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleDoubleVector_resize", _wrap_DoubleDoubleVector_resize, METH_VARARGS, NULL},
	 { "DoubleDoubleVector_insert", _wrap_DoubleDoubleVector_insert, METH_VARARGS, NULL},
	 { "DoubleDoubleVector_reserve", (PyCFunction)(void(*)(void))_wrap_DoubleDoubleVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DoubleDoubleVector_capacity", _wrap_DoubleDoubleVector_capacity, METH_O, NULL},
	 { "delete_DoubleDoubleVector", _wrap_delete_DoubleDoubleVector, METH_O, NULL},
	 { "DoubleDoubleVector_swigregister", DoubleDoubleVector_swigregister, METH_O, NULL},
	 { "DoubleDoubleVector_swiginit", DoubleDoubleVector_swiginit, METH_VARARGS, NULL},
	 { "IntIntVector_iterator", _wrap_IntIntVector_iterator, METH_O, NULL},
	 { "IntIntVector___nonzero__", _wrap_IntIntVector___nonzero__, METH_O, NULL},
	 { "IntIntVector___bool__", _wrap_IntIntVector___bool__, METH_O, NULL},
	 { "IntIntVector___len__", _wrap_IntIntVector___len__, METH_O, NULL},
	 { "IntIntVector___getslice__", (PyCFunction)(void(*)(void))_wrap_IntIntVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntIntVector___setslice__", _wrap_IntIntVector___setslice__, METH_VARARGS, NULL},
	 { "IntIntVector___delslice__", (PyCFunction)(void(*)(void))_wrap_IntIntVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntIntVector___delitem__", _wrap_IntIntVector___delitem__, METH_VARARGS, NULL},
	 { "IntIntVector___getitem__", _wrap_IntIntVector___getitem__, METH_VARARGS, NULL},
	 { "IntIntVector___setitem__", _wrap_IntIntVector___setitem__, METH_VARARGS, NULL},
	 { "IntIntVector_pop", _wrap_IntIntVector_pop, METH_O, NULL},
	 { "IntIntVector_append", (PyCFunction)(void(*)(void))_wrap_IntIntVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntIntVector_empty", _wrap_IntIntVector_empty, METH_O, NULL},
	 { "IntIntVector_size", _wrap_IntIntVector_size, METH_O, NULL},
	 { "IntIntVector_swap", (PyCFunction)(void(*)(void))_wrap_IntIntVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntIntVector_begin", _wrap_IntIntVector_begin, METH_O, NULL},
	 { "IntIntVector_end", _wrap_IntIntVector_end, METH_O, NULL},
	 { "IntIntVector_rbegin", _wrap_IntIntVector_rbegin, METH_O, NULL},
	 { "IntIntVector_rend", _wrap_IntIntVector_rend, METH_O, NULL},
	 { "IntIntVector_clear", _wrap_IntIntVector_clear, METH_O, NULL},
	 { "IntIntVector_get_allocator", _wrap_IntIntVector_get_allocator, METH_O, NULL},
	 { "IntIntVector_pop_back", _wrap_IntIntVector_pop_back, METH_O, NULL},
	 { "IntIntVector_erase", _wrap_IntIntVector_erase, METH_VARARGS, NULL},
	 { "new_IntIntVector", _wrap_new_IntIntVector, METH_VARARGS, NULL},
	 { "IntIntVector_push_back", (PyCFunction)(void(*)(void))_wrap_IntIntVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntIntVector_front", _wrap_IntIntVector_front, METH_O, NULL},
	 { "IntIntVector_back", _wrap_IntIntVector_back, METH_O, NULL},
	 { "IntIntVector_assign", (PyCFunction)(void(*)(void))_wrap_IntIntVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntIntVector_resize", _wrap_IntIntVector_resize, METH_VARARGS, NULL},
	 { "IntIntVector_insert", _wrap_IntIntVector_insert, METH_VARARGS, NULL},
	 { "IntIntVector_reserve", (PyCFunction)(void(*)(void))_wrap_IntIntVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "IntIntVector_capacity", _wrap_IntIntVector_capacity, METH_O, NULL},
	 { "delete_IntIntVector", _wrap_delete_IntIntVector, METH_O, NULL},
	 { "IntIntVector_swigregister", IntIntVector_swigregister, METH_O, NULL},
	 { "IntIntVector_swiginit", IntIntVector_swiginit, METH_VARARGS, NULL},
	 { "ElemProbVector_iterator", _wrap_ElemProbVector_iterator, METH_O, NULL},
	 { "ElemProbVector___nonzero__", _wrap_ElemProbVector___nonzero__, METH_O, NULL},
	 { "ElemProbVector___bool__", _wrap_ElemProbVector___bool__, METH_O, NULL},
	 { "ElemProbVector___len__", _wrap_ElemProbVector___len__, METH_O, NULL},
	 { "ElemProbVector___getslice__", (PyCFunction)(void(*)(void))_wrap_ElemProbVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ElemProbVector___setslice__", _wrap_ElemProbVector___setslice__, METH_VARARGS, NULL},
	 { "ElemProbVector___delslice__", (PyCFunction)(void(*)(void))_wrap_ElemProbVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ElemProbVector___delitem__", _wrap_ElemProbVector___delitem__, METH_VARARGS, NULL},
	 { "ElemProbVector___getitem__", _wrap_ElemProbVector___getitem__, METH_VARARGS, NULL},
	 { "ElemProbVector___setitem__", _wrap_ElemProbVector___setitem__, METH_VARARGS, NULL},
	 { "ElemProbVector_pop", _wrap_ElemProbVector_pop, METH_O, NULL},
	 { "ElemProbVector_append", (PyCFunction)(void(*)(void))_wrap_ElemProbVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ElemProbVector_empty", _wrap_ElemProbVector_empty, METH_O, NULL},
	 { "ElemProbVector_size", _wrap_ElemProbVector_size, METH_O, NULL},
	 { "ElemProbVector_swap", (PyCFunction)(void(*)(void))_wrap_ElemProbVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ElemProbVector_begin", _wrap_ElemProbVector_begin, METH_O, NULL},
	 { "ElemProbVector_end", _wrap_ElemProbVector_end, METH_O, NULL},
	 { "ElemProbVector_rbegin", _wrap_ElemProbVector_rbegin, METH_O, NULL},
	 { "ElemProbVector_rend", _wrap_ElemProbVector_rend, METH_O, NULL},
	 { "ElemProbVector_clear", _wrap_ElemProbVector_clear, METH_O, NULL},
	 { "ElemProbVector_get_allocator", _wrap_ElemProbVector_get_allocator, METH_O, NULL},
	 { "ElemProbVector_pop_back", _wrap_ElemProbVector_pop_back, METH_O, NULL},
	 { "ElemProbVector_erase", _wrap_ElemProbVector_erase, METH_VARARGS, NULL},
	 { "new_ElemProbVector", _wrap_new_ElemProbVector, METH_VARARGS, NULL},
	 { "ElemProbVector_push_back", (PyCFunction)(void(*)(void))_wrap_ElemProbVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ElemProbVector_front", _wrap_ElemProbVector_front, METH_O, NULL},
	 { "ElemProbVector_back", _wrap_ElemProbVector_back, METH_O, NULL},
	 { "ElemProbVector_assign", (PyCFunction)(void(*)(void))_wrap_ElemProbVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ElemProbVector_resize", _wrap_ElemProbVector_resize, METH_VARARGS, NULL},
	 { "ElemProbVector_insert", _wrap_ElemProbVector_insert, METH_VARARGS, NULL},
	 { "ElemProbVector_reserve", (PyCFunction)(void(*)(void))_wrap_ElemProbVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ElemProbVector_capacity", _wrap_ElemProbVector_capacity, METH_O, NULL},
	 { "delete_ElemProbVector", _wrap_delete_ElemProbVector, METH_O, NULL},
	 { "ElemProbVector_swigregister", ElemProbVector_swigregister, METH_O, NULL},
	 { "ElemProbVector_swiginit", ElemProbVector_swiginit, METH_VARARGS, NULL},
	 { "HelixVector_iterator", _wrap_HelixVector_iterator, METH_O, NULL},
	 { "HelixVector___nonzero__", _wrap_HelixVector___nonzero__, METH_O, NULL},
	 { "HelixVector___bool__", _wrap_HelixVector___bool__, METH_O, NULL},
	 { "HelixVector___len__", _wrap_HelixVector___len__, METH_O, NULL},
	 { "HelixVector___getslice__", (PyCFunction)(void(*)(void))_wrap_HelixVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HelixVector___setslice__", _wrap_HelixVector___setslice__, METH_VARARGS, NULL},
	 { "HelixVector___delslice__", (PyCFunction)(void(*)(void))_wrap_HelixVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HelixVector___delitem__", _wrap_HelixVector___delitem__, METH_VARARGS, NULL},
	 { "HelixVector___getitem__", _wrap_HelixVector___getitem__, METH_VARARGS, NULL},
	 { "HelixVector___setitem__", _wrap_HelixVector___setitem__, METH_VARARGS, NULL},
	 { "HelixVector_pop", _wrap_HelixVector_pop, METH_O, NULL},
	 { "HelixVector_append", (PyCFunction)(void(*)(void))_wrap_HelixVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HelixVector_empty", _wrap_HelixVector_empty, METH_O, NULL},
	 { "HelixVector_size", _wrap_HelixVector_size, METH_O, NULL},
	 { "HelixVector_swap", (PyCFunction)(void(*)(void))_wrap_HelixVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HelixVector_begin", _wrap_HelixVector_begin, METH_O, NULL},
	 { "HelixVector_end", _wrap_HelixVector_end, METH_O, NULL},
	 { "HelixVector_rbegin", _wrap_HelixVector_rbegin, METH_O, NULL},
	 { "HelixVector_rend", _wrap_HelixVector_rend, METH_O, NULL},
	 { "HelixVector_clear", _wrap_HelixVector_clear, METH_O, NULL},
	 { "HelixVector_get_allocator", _wrap_HelixVector_get_allocator, METH_O, NULL},
	 { "HelixVector_pop_back", _wrap_HelixVector_pop_back, METH_O, NULL},
	 { "HelixVector_erase", _wrap_HelixVector_erase, METH_VARARGS, NULL},
	 { "new_HelixVector", _wrap_new_HelixVector, METH_VARARGS, NULL},
	 { "HelixVector_push_back", (PyCFunction)(void(*)(void))_wrap_HelixVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HelixVector_front", _wrap_HelixVector_front, METH_O, NULL},
	 { "HelixVector_back", _wrap_HelixVector_back, METH_O, NULL},
	 { "HelixVector_assign", (PyCFunction)(void(*)(void))_wrap_HelixVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HelixVector_resize", _wrap_HelixVector_resize, METH_VARARGS, NULL},
	 { "HelixVector_insert", _wrap_HelixVector_insert, METH_VARARGS, NULL},
	 { "HelixVector_reserve", (PyCFunction)(void(*)(void))_wrap_HelixVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HelixVector_capacity", _wrap_HelixVector_capacity, METH_O, NULL},
	 { "delete_HelixVector", _wrap_delete_HelixVector, METH_O, NULL},
	 { "HelixVector_swigregister", HelixVector_swigregister, METH_O, NULL},
	 { "HelixVector_swiginit", HelixVector_swiginit, METH_VARARGS, NULL},
	 { "PathVector_iterator", _wrap_PathVector_iterator, METH_O, NULL},
	 { "PathVector___nonzero__", _wrap_PathVector___nonzero__, METH_O, NULL},
	 { "PathVector___bool__", _wrap_PathVector___bool__, METH_O, NULL},
	 { "PathVector___len__", _wrap_PathVector___len__, METH_O, NULL},
	 { "PathVector___getslice__", (PyCFunction)(void(*)(void))_wrap_PathVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PathVector___setslice__", _wrap_PathVector___setslice__, METH_VARARGS, NULL},
	 { "PathVector___delslice__", (PyCFunction)(void(*)(void))_wrap_PathVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PathVector___delitem__", _wrap_PathVector___delitem__, METH_VARARGS, NULL},
	 { "PathVector___getitem__", _wrap_PathVector___getitem__, METH_VARARGS, NULL},
	 { "PathVector___setitem__", _wrap_PathVector___setitem__, METH_VARARGS, NULL},
	 { "PathVector_pop", _wrap_PathVector_pop, METH_O, NULL},
	 { "PathVector_append", (PyCFunction)(void(*)(void))_wrap_PathVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PathVector_empty", _wrap_PathVector_empty, METH_O, NULL},
	 { "PathVector_size", _wrap_PathVector_size, METH_O, NULL},
	 { "PathVector_swap", (PyCFunction)(void(*)(void))_wrap_PathVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PathVector_begin", _wrap_PathVector_begin, METH_O, NULL},
	 { "PathVector_end", _wrap_PathVector_end, METH_O, NULL},
	 { "PathVector_rbegin", _wrap_PathVector_rbegin, METH_O, NULL},
	 { "PathVector_rend", _wrap_PathVector_rend, METH_O, NULL},
	 { "PathVector_clear", _wrap_PathVector_clear, METH_O, NULL},
	 { "PathVector_get_allocator", _wrap_PathVector_get_allocator, METH_O, NULL},
	 { "PathVector_pop_back", _wrap_PathVector_pop_back, METH_O, NULL},
	 { "PathVector_erase", _wrap_PathVector_erase, METH_VARARGS, NULL},
	 { "new_PathVector", _wrap_new_PathVector, METH_VARARGS, NULL},
	 { "PathVector_push_back", (PyCFunction)(void(*)(void))_wrap_PathVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PathVector_front", _wrap_PathVector_front, METH_O, NULL},
	 { "PathVector_back", _wrap_PathVector_back, METH_O, NULL},
	 { "PathVector_assign", (PyCFunction)(void(*)(void))_wrap_PathVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PathVector_resize", _wrap_PathVector_resize, METH_VARARGS, NULL},
	 { "PathVector_insert", _wrap_PathVector_insert, METH_VARARGS, NULL},
	 { "PathVector_reserve", (PyCFunction)(void(*)(void))_wrap_PathVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "PathVector_capacity", _wrap_PathVector_capacity, METH_O, NULL},
	 { "delete_PathVector", _wrap_delete_PathVector, METH_O, NULL},
	 { "PathVector_swigregister", PathVector_swigregister, METH_O, NULL},
	 { "PathVector_swiginit", PathVector_swiginit, METH_VARARGS, NULL},
	 { "MoveVector_iterator", _wrap_MoveVector_iterator, METH_O, NULL},
	 { "MoveVector___nonzero__", _wrap_MoveVector___nonzero__, METH_O, NULL},
	 { "MoveVector___bool__", _wrap_MoveVector___bool__, METH_O, NULL},
	 { "MoveVector___len__", _wrap_MoveVector___len__, METH_O, NULL},
	 { "MoveVector___getslice__", (PyCFunction)(void(*)(void))_wrap_MoveVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "MoveVector___setslice__", _wrap_MoveVector___setslice__, METH_VARARGS, NULL},
	 { "MoveVector___delslice__", (PyCFunction)(void(*)(void))_wrap_MoveVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "MoveVector___delitem__", _wrap_MoveVector___delitem__, METH_VARARGS, NULL},
	 { "MoveVector___getitem__", _wrap_MoveVector___getitem__, METH_VARARGS, NULL},
	 { "MoveVector___setitem__", _wrap_MoveVector___setitem__, METH_VARARGS, NULL},
	 { "MoveVector_pop", _wrap_MoveVector_pop, METH_O, NULL},
	 { "MoveVector_append", (PyCFunction)(void(*)(void))_wrap_MoveVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "MoveVector_empty", _wrap_MoveVector_empty, METH_O, NULL},
	 { "MoveVector_size", _wrap_MoveVector_size, METH_O, NULL},
	 { "MoveVector_swap", (PyCFunction)(void(*)(void))_wrap_MoveVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "MoveVector_begin", _wrap_MoveVector_begin, METH_O, NULL},
	 { "MoveVector_end", _wrap_MoveVector_end, METH_O, NULL},
	 { "MoveVector_rbegin", _wrap_MoveVector_rbegin, METH_O, NULL},
	 { "MoveVector_rend", _wrap_MoveVector_rend, METH_O, NULL},
	 { "MoveVector_clear", _wrap_MoveVector_clear, METH_O, NULL},
	 { "MoveVector_get_allocator", _wrap_MoveVector_get_allocator, METH_O, NULL},
	 { "MoveVector_pop_back", _wrap_MoveVector_pop_back, METH_O, NULL},
	 { "MoveVector_erase", _wrap_MoveVector_erase, METH_VARARGS, NULL},
	 { "new_MoveVector", _wrap_new_MoveVector, METH_VARARGS, NULL},
	 { "MoveVector_push_back", (PyCFunction)(void(*)(void))_wrap_MoveVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "MoveVector_front", _wrap_MoveVector_front, METH_O, NULL},
	 { "MoveVector_back", _wrap_MoveVector_back, METH_O, NULL},
	 { "MoveVector_assign", (PyCFunction)(void(*)(void))_wrap_MoveVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "MoveVector_resize", _wrap_MoveVector_resize, METH_VARARGS, NULL},
	 { "MoveVector_insert", _wrap_MoveVector_insert, METH_VARARGS, NULL},
	 { "MoveVector_reserve", (PyCFunction)(void(*)(void))_wrap_MoveVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "MoveVector_capacity", _wrap_MoveVector_capacity, METH_O, NULL},
	 { "delete_MoveVector", _wrap_delete_MoveVector, METH_O, NULL},
	 { "MoveVector_swigregister", MoveVector_swigregister, METH_O, NULL},
	 { "MoveVector_swiginit", MoveVector_swiginit, METH_VARARGS, NULL},
	 { "new_varArrayUChar", (PyCFunction)(void(*)(void))_wrap_new_varArrayUChar, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_varArrayUChar", _wrap_delete_varArrayUChar, METH_O, NULL},
	 { "varArrayUChar_type", _wrap_varArrayUChar_type, METH_O, NULL},
	 { "varArrayUChar_size", _wrap_varArrayUChar_size, METH_O, NULL},
	 { "varArrayUChar___len__", _wrap_varArrayUChar___len__, METH_O, NULL},
	 { "varArrayUChar_get", (PyCFunction)(void(*)(void))_wrap_varArrayUChar_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayUChar___setitem__", (PyCFunction)(void(*)(void))_wrap_varArrayUChar___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayUChar___getitem__", _wrap_varArrayUChar___getitem__, METH_VARARGS, NULL},
	 { "varArrayUChar_swigregister", varArrayUChar_swigregister, METH_O, NULL},
	 { "varArrayUChar_swiginit", varArrayUChar_swiginit, METH_VARARGS, NULL},
	 { "new_varArrayChar", (PyCFunction)(void(*)(void))_wrap_new_varArrayChar, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_varArrayChar", _wrap_delete_varArrayChar, METH_O, NULL},
	 { "varArrayChar_type", _wrap_varArrayChar_type, METH_O, NULL},
	 { "varArrayChar_size", _wrap_varArrayChar_size, METH_O, NULL},
	 { "varArrayChar___len__", _wrap_varArrayChar___len__, METH_O, NULL},
	 { "varArrayChar_get", (PyCFunction)(void(*)(void))_wrap_varArrayChar_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayChar___setitem__", (PyCFunction)(void(*)(void))_wrap_varArrayChar___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayChar___getitem__", _wrap_varArrayChar___getitem__, METH_VARARGS, NULL},
	 { "varArrayChar_swigregister", varArrayChar_swigregister, METH_O, NULL},
	 { "varArrayChar_swiginit", varArrayChar_swiginit, METH_VARARGS, NULL},
	 { "delete_varArrayShort", _wrap_delete_varArrayShort, METH_O, NULL},
	 { "varArrayShort_type", _wrap_varArrayShort_type, METH_O, NULL},
	 { "varArrayShort_size", _wrap_varArrayShort_size, METH_O, NULL},
	 { "varArrayShort___len__", _wrap_varArrayShort___len__, METH_O, NULL},
	 { "varArrayShort_get", (PyCFunction)(void(*)(void))_wrap_varArrayShort_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayShort___setitem__", (PyCFunction)(void(*)(void))_wrap_varArrayShort___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "new_varArrayShort", _wrap_new_varArrayShort, METH_VARARGS, NULL},
	 { "varArrayShort___getitem__", _wrap_varArrayShort___getitem__, METH_VARARGS, NULL},
	 { "varArrayShort_swigregister", varArrayShort_swigregister, METH_O, NULL},
	 { "varArrayShort_swiginit", varArrayShort_swiginit, METH_VARARGS, NULL},
	 { "new_varArrayUInt", (PyCFunction)(void(*)(void))_wrap_new_varArrayUInt, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_varArrayUInt", _wrap_delete_varArrayUInt, METH_O, NULL},
	 { "varArrayUInt_type", _wrap_varArrayUInt_type, METH_O, NULL},
	 { "varArrayUInt_size", _wrap_varArrayUInt_size, METH_O, NULL},
	 { "varArrayUInt___len__", _wrap_varArrayUInt___len__, METH_O, NULL},
	 { "varArrayUInt_get", (PyCFunction)(void(*)(void))_wrap_varArrayUInt_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayUInt___setitem__", (PyCFunction)(void(*)(void))_wrap_varArrayUInt___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayUInt___getitem__", _wrap_varArrayUInt___getitem__, METH_VARARGS, NULL},
	 { "varArrayUInt_swigregister", varArrayUInt_swigregister, METH_O, NULL},
	 { "varArrayUInt_swiginit", varArrayUInt_swiginit, METH_VARARGS, NULL},
	 { "new_varArrayInt", (PyCFunction)(void(*)(void))_wrap_new_varArrayInt, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_varArrayInt", _wrap_delete_varArrayInt, METH_O, NULL},
	 { "varArrayInt_type", _wrap_varArrayInt_type, METH_O, NULL},
	 { "varArrayInt_size", _wrap_varArrayInt_size, METH_O, NULL},
	 { "varArrayInt___len__", _wrap_varArrayInt___len__, METH_O, NULL},
	 { "varArrayInt_get", (PyCFunction)(void(*)(void))_wrap_varArrayInt_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayInt___setitem__", (PyCFunction)(void(*)(void))_wrap_varArrayInt___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayInt___getitem__", _wrap_varArrayInt___getitem__, METH_VARARGS, NULL},
	 { "varArrayInt_swigregister", varArrayInt_swigregister, METH_O, NULL},
	 { "varArrayInt_swiginit", varArrayInt_swiginit, METH_VARARGS, NULL},
	 { "new_varArrayFLTorDBL", (PyCFunction)(void(*)(void))_wrap_new_varArrayFLTorDBL, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_varArrayFLTorDBL", _wrap_delete_varArrayFLTorDBL, METH_O, NULL},
	 { "varArrayFLTorDBL_type", _wrap_varArrayFLTorDBL_type, METH_O, NULL},
	 { "varArrayFLTorDBL_size", _wrap_varArrayFLTorDBL_size, METH_O, NULL},
	 { "varArrayFLTorDBL___len__", _wrap_varArrayFLTorDBL___len__, METH_O, NULL},
	 { "varArrayFLTorDBL_get", (PyCFunction)(void(*)(void))_wrap_varArrayFLTorDBL_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayFLTorDBL___setitem__", (PyCFunction)(void(*)(void))_wrap_varArrayFLTorDBL___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayFLTorDBL___getitem__", _wrap_varArrayFLTorDBL___getitem__, METH_VARARGS, NULL},
	 { "varArrayFLTorDBL_swigregister", varArrayFLTorDBL_swigregister, METH_O, NULL},
	 { "varArrayFLTorDBL_swiginit", varArrayFLTorDBL_swiginit, METH_VARARGS, NULL},
	 { "new_varArrayMove", (PyCFunction)(void(*)(void))_wrap_new_varArrayMove, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_varArrayMove", _wrap_delete_varArrayMove, METH_O, NULL},
	 { "varArrayMove_type", _wrap_varArrayMove_type, METH_O, NULL},
	 { "varArrayMove_size", _wrap_varArrayMove_size, METH_O, NULL},
	 { "varArrayMove___len__", _wrap_varArrayMove___len__, METH_O, NULL},
	 { "varArrayMove_get", (PyCFunction)(void(*)(void))_wrap_varArrayMove_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayMove___setitem__", (PyCFunction)(void(*)(void))_wrap_varArrayMove___setitem__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "varArrayMove___getitem__", _wrap_varArrayMove___getitem__, METH_VARARGS, NULL},
	 { "varArrayMove_swigregister", varArrayMove_swigregister, METH_O, NULL},
	 { "varArrayMove_swiginit", varArrayMove_swiginit, METH_VARARGS, NULL},
	 { "basepair_i_set", _wrap_basepair_i_set, METH_VARARGS, NULL},
	 { "basepair_i_get", _wrap_basepair_i_get, METH_O, NULL},
	 { "basepair_j_set", _wrap_basepair_j_set, METH_VARARGS, NULL},
	 { "basepair_j_get", _wrap_basepair_j_get, METH_O, NULL},
	 { "new_basepair", _wrap_new_basepair, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Typename for base pair element.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.bp() instead!  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"i : int  \n"
		"\n"
		"j : int  \n"
		"\n"
		""},
	 { "delete_basepair", _wrap_delete_basepair, METH_O, NULL},
	 { "basepair_swigregister", basepair_swigregister, METH_O, NULL},
	 { "basepair_swiginit", basepair_swiginit, METH_VARARGS, NULL},
	 { "duplexT_i_set", _wrap_duplexT_i_set, METH_VARARGS, NULL},
	 { "duplexT_i_get", _wrap_duplexT_i_get, METH_O, NULL},
	 { "duplexT_j_set", _wrap_duplexT_j_set, METH_VARARGS, NULL},
	 { "duplexT_j_get", _wrap_duplexT_j_get, METH_O, NULL},
	 { "duplexT_end_set", _wrap_duplexT_end_set, METH_VARARGS, NULL},
	 { "duplexT_end_get", _wrap_duplexT_end_get, METH_O, NULL},
	 { "duplexT_structure_set", _wrap_duplexT_structure_set, METH_VARARGS, NULL},
	 { "duplexT_structure_get", _wrap_duplexT_structure_get, METH_O, NULL},
	 { "duplexT_energy_set", _wrap_duplexT_energy_set, METH_VARARGS, NULL},
	 { "duplexT_energy_get", _wrap_duplexT_energy_get, METH_O, NULL},
	 { "duplexT_energy_backtrack_set", _wrap_duplexT_energy_backtrack_set, METH_VARARGS, NULL},
	 { "duplexT_energy_backtrack_get", _wrap_duplexT_energy_backtrack_get, METH_O, NULL},
	 { "duplexT_opening_backtrack_x_set", _wrap_duplexT_opening_backtrack_x_set, METH_VARARGS, NULL},
	 { "duplexT_opening_backtrack_x_get", _wrap_duplexT_opening_backtrack_x_get, METH_O, NULL},
	 { "duplexT_opening_backtrack_y_set", _wrap_duplexT_opening_backtrack_y_set, METH_VARARGS, NULL},
	 { "duplexT_opening_backtrack_y_get", _wrap_duplexT_opening_backtrack_y_get, METH_O, NULL},
	 { "duplexT_offset_set", _wrap_duplexT_offset_set, METH_VARARGS, NULL},
	 { "duplexT_offset_get", _wrap_duplexT_offset_get, METH_O, NULL},
	 { "duplexT_dG1_set", _wrap_duplexT_dG1_set, METH_VARARGS, NULL},
	 { "duplexT_dG1_get", _wrap_duplexT_dG1_get, METH_O, NULL},
	 { "duplexT_dG2_set", _wrap_duplexT_dG2_set, METH_VARARGS, NULL},
	 { "duplexT_dG2_get", _wrap_duplexT_dG2_get, METH_O, NULL},
	 { "duplexT_ddG_set", _wrap_duplexT_ddG_set, METH_VARARGS, NULL},
	 { "duplexT_ddG_get", _wrap_duplexT_ddG_get, METH_O, NULL},
	 { "duplexT_tb_set", _wrap_duplexT_tb_set, METH_VARARGS, NULL},
	 { "duplexT_tb_get", _wrap_duplexT_tb_get, METH_O, NULL},
	 { "duplexT_te_set", _wrap_duplexT_te_set, METH_VARARGS, NULL},
	 { "duplexT_te_get", _wrap_duplexT_te_get, METH_O, NULL},
	 { "duplexT_qb_set", _wrap_duplexT_qb_set, METH_VARARGS, NULL},
	 { "duplexT_qb_get", _wrap_duplexT_qb_get, METH_O, NULL},
	 { "duplexT_qe_set", _wrap_duplexT_qe_set, METH_VARARGS, NULL},
	 { "duplexT_qe_get", _wrap_duplexT_qe_get, METH_O, NULL},
	 { "delete_duplexT", _wrap_delete_duplexT, METH_O, NULL},
	 { "duplexT_swigregister", duplexT_swigregister, METH_O, NULL},
	 { "param_id_get", _wrap_param_id_get, METH_O, NULL},
	 { "param_stack_get", _wrap_param_stack_get, METH_O, NULL},
	 { "param_hairpin_get", _wrap_param_hairpin_get, METH_O, NULL},
	 { "param_bulge_get", _wrap_param_bulge_get, METH_O, NULL},
	 { "param_internal_loop_get", _wrap_param_internal_loop_get, METH_O, NULL},
	 { "param_mismatchExt_get", _wrap_param_mismatchExt_get, METH_O, NULL},
	 { "param_mismatchI_get", _wrap_param_mismatchI_get, METH_O, NULL},
	 { "param_mismatch1nI_get", _wrap_param_mismatch1nI_get, METH_O, NULL},
	 { "param_mismatch23I_get", _wrap_param_mismatch23I_get, METH_O, NULL},
	 { "param_mismatchH_get", _wrap_param_mismatchH_get, METH_O, NULL},
	 { "param_mismatchM_get", _wrap_param_mismatchM_get, METH_O, NULL},
	 { "param_dangle5_get", _wrap_param_dangle5_get, METH_O, NULL},
	 { "param_dangle3_get", _wrap_param_dangle3_get, METH_O, NULL},
	 { "param_int11_get", _wrap_param_int11_get, METH_O, NULL},
	 { "param_int21_get", _wrap_param_int21_get, METH_O, NULL},
	 { "param_int22_get", _wrap_param_int22_get, METH_O, NULL},
	 { "param_ninio_get", _wrap_param_ninio_get, METH_O, NULL},
	 { "param_lxc_get", _wrap_param_lxc_get, METH_O, NULL},
	 { "param_MLbase_get", _wrap_param_MLbase_get, METH_O, NULL},
	 { "param_MLintern_get", _wrap_param_MLintern_get, METH_O, NULL},
	 { "param_MLclosing_get", _wrap_param_MLclosing_get, METH_O, NULL},
	 { "param_TerminalAU_get", _wrap_param_TerminalAU_get, METH_O, NULL},
	 { "param_DuplexInit_get", _wrap_param_DuplexInit_get, METH_O, NULL},
	 { "param_Tetraloop_E_get", _wrap_param_Tetraloop_E_get, METH_O, NULL},
	 { "param_Tetraloops_get", _wrap_param_Tetraloops_get, METH_O, NULL},
	 { "param_Triloop_E_get", _wrap_param_Triloop_E_get, METH_O, NULL},
	 { "param_Triloops_get", _wrap_param_Triloops_get, METH_O, NULL},
	 { "param_Hexaloop_E_get", _wrap_param_Hexaloop_E_get, METH_O, NULL},
	 { "param_Hexaloops_get", _wrap_param_Hexaloops_get, METH_O, NULL},
	 { "param_TripleC_get", _wrap_param_TripleC_get, METH_O, NULL},
	 { "param_MultipleCA_get", _wrap_param_MultipleCA_get, METH_O, NULL},
	 { "param_MultipleCB_get", _wrap_param_MultipleCB_get, METH_O, NULL},
	 { "param_gquad_get", _wrap_param_gquad_get, METH_O, NULL},
	 { "param_gquadLayerMismatch_get", _wrap_param_gquadLayerMismatch_get, METH_O, NULL},
	 { "param_gquadLayerMismatchMax_get", _wrap_param_gquadLayerMismatchMax_get, METH_O, NULL},
	 { "param_temperature_get", _wrap_param_temperature_get, METH_O, NULL},
	 { "param_model_details_get", _wrap_param_model_details_get, METH_O, NULL},
	 { "param_param_file_get", _wrap_param_param_file_get, METH_O, NULL},
	 { "param_SaltStack_get", _wrap_param_SaltStack_get, METH_O, NULL},
	 { "param_SaltLoop_get", _wrap_param_SaltLoop_get, METH_O, NULL},
	 { "param_SaltLoopDbl_get", _wrap_param_SaltLoopDbl_get, METH_O, NULL},
	 { "param_SaltMLbase_get", _wrap_param_SaltMLbase_get, METH_O, NULL},
	 { "param_SaltMLintern_get", _wrap_param_SaltMLintern_get, METH_O, NULL},
	 { "param_SaltMLclosing_get", _wrap_param_SaltMLclosing_get, METH_O, NULL},
	 { "param_SaltDPXInit_get", _wrap_param_SaltDPXInit_get, METH_O, NULL},
	 { "new_param", (PyCFunction)(void(*)(void))_wrap_new_param, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"The datastructure that contains temperature scaled energy parameters.  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"id : int  \n"
		"\n"
		"stack : int  \n"
		"\n"
		"hairpin : int  \n"
		"\n"
		"bulge : int  \n"
		"\n"
		"internal_loop : int  \n"
		"\n"
		"mismatchExt : int  \n"
		"\n"
		"mismatchI : int  \n"
		"\n"
		"mismatch1nI : int  \n"
		"\n"
		"mismatch23I : int  \n"
		"\n"
		"mismatchH : int  \n"
		"\n"
		"mismatchM : int  \n"
		"\n"
		"dangle5 : int  \n"
		"\n"
		"dangle3 : int  \n"
		"\n"
		"int11 : int  \n"
		"\n"
		"int21 : int  \n"
		"\n"
		"int22 : int  \n"
		"\n"
		"ninio : int  \n"
		"\n"
		"lxc : double  \n"
		"\n"
		"MLbase : int  \n"
		"\n"
		"MLintern : int  \n"
		"\n"
		"MLclosing : int  \n"
		"\n"
		"TerminalAU : int  \n"
		"\n"
		"DuplexInit : int  \n"
		"\n"
		"Tetraloop_E : int  \n"
		"\n"
		"Tetraloops : char  \n"
		"\n"
		"Triloop_E : int  \n"
		"\n"
		"Triloops : char  \n"
		"\n"
		"Hexaloop_E : int  \n"
		"\n"
		"Hexaloops : char  \n"
		"\n"
		"TripleC : int  \n"
		"\n"
		"MultipleCA : int  \n"
		"\n"
		"MultipleCB : int  \n"
		"\n"
		"gquad : int  \n"
		"\n"
		"gquadLayerMismatch : int  \n"
		"\n"
		"gquadLayerMismatchMax : unsigned int  \n"
		"\n"
		"temperature : double  \n"
		"    Temperature used for loop contribution scaling.  \n"
		"\n"
		"model_details : vrna_md_t  \n"
		"    Model details to be used in the recursions.  \n"
		"\n"
		"param_file : char  \n"
		"    The filename the parameters were derived from, or empty string if they represent the default.  \n"
		"\n"
		"SaltStack : int  \n"
		"\n"
		"SaltLoop : int  \n"
		"\n"
		"SaltLoopDbl : double  \n"
		"\n"
		"SaltMLbase : int  \n"
		"\n"
		"SaltMLintern : int  \n"
		"\n"
		"SaltMLclosing : int  \n"
		"\n"
		"SaltDPXInit : int  \n"
		"\n"
		""},
	 { "delete_param", _wrap_delete_param, METH_O, NULL},
	 { "param___str__", _wrap_param___str__, METH_O, NULL},
	 { "param_swigregister", param_swigregister, METH_O, NULL},
	 { "param_swiginit", param_swiginit, METH_VARARGS, NULL},
	 { "exp_param_id_get", _wrap_exp_param_id_get, METH_O, NULL},
	 { "exp_param_expstack_get", _wrap_exp_param_expstack_get, METH_O, NULL},
	 { "exp_param_exphairpin_get", _wrap_exp_param_exphairpin_get, METH_O, NULL},
	 { "exp_param_expbulge_get", _wrap_exp_param_expbulge_get, METH_O, NULL},
	 { "exp_param_expinternal_get", _wrap_exp_param_expinternal_get, METH_O, NULL},
	 { "exp_param_expmismatchExt_get", _wrap_exp_param_expmismatchExt_get, METH_O, NULL},
	 { "exp_param_expmismatchI_get", _wrap_exp_param_expmismatchI_get, METH_O, NULL},
	 { "exp_param_expmismatch23I_get", _wrap_exp_param_expmismatch23I_get, METH_O, NULL},
	 { "exp_param_expmismatch1nI_get", _wrap_exp_param_expmismatch1nI_get, METH_O, NULL},
	 { "exp_param_expmismatchH_get", _wrap_exp_param_expmismatchH_get, METH_O, NULL},
	 { "exp_param_expmismatchM_get", _wrap_exp_param_expmismatchM_get, METH_O, NULL},
	 { "exp_param_expdangle5_get", _wrap_exp_param_expdangle5_get, METH_O, NULL},
	 { "exp_param_expdangle3_get", _wrap_exp_param_expdangle3_get, METH_O, NULL},
	 { "exp_param_expint11_get", _wrap_exp_param_expint11_get, METH_O, NULL},
	 { "exp_param_expint21_get", _wrap_exp_param_expint21_get, METH_O, NULL},
	 { "exp_param_expint22_get", _wrap_exp_param_expint22_get, METH_O, NULL},
	 { "exp_param_expninio_get", _wrap_exp_param_expninio_get, METH_O, NULL},
	 { "exp_param_lxc_get", _wrap_exp_param_lxc_get, METH_O, NULL},
	 { "exp_param_expMLbase_get", _wrap_exp_param_expMLbase_get, METH_O, NULL},
	 { "exp_param_expMLintern_get", _wrap_exp_param_expMLintern_get, METH_O, NULL},
	 { "exp_param_expMLclosing_get", _wrap_exp_param_expMLclosing_get, METH_O, NULL},
	 { "exp_param_expTermAU_get", _wrap_exp_param_expTermAU_get, METH_O, NULL},
	 { "exp_param_expDuplexInit_get", _wrap_exp_param_expDuplexInit_get, METH_O, NULL},
	 { "exp_param_exptetra_get", _wrap_exp_param_exptetra_get, METH_O, NULL},
	 { "exp_param_exptri_get", _wrap_exp_param_exptri_get, METH_O, NULL},
	 { "exp_param_exphex_get", _wrap_exp_param_exphex_get, METH_O, NULL},
	 { "exp_param_Tetraloops_get", _wrap_exp_param_Tetraloops_get, METH_O, NULL},
	 { "exp_param_expTriloop_get", _wrap_exp_param_expTriloop_get, METH_O, NULL},
	 { "exp_param_Triloops_get", _wrap_exp_param_Triloops_get, METH_O, NULL},
	 { "exp_param_Hexaloops_get", _wrap_exp_param_Hexaloops_get, METH_O, NULL},
	 { "exp_param_expTripleC_get", _wrap_exp_param_expTripleC_get, METH_O, NULL},
	 { "exp_param_expMultipleCA_get", _wrap_exp_param_expMultipleCA_get, METH_O, NULL},
	 { "exp_param_expMultipleCB_get", _wrap_exp_param_expMultipleCB_get, METH_O, NULL},
	 { "exp_param_expgquad_get", _wrap_exp_param_expgquad_get, METH_O, NULL},
	 { "exp_param_expgquadLayerMismatch_get", _wrap_exp_param_expgquadLayerMismatch_get, METH_O, NULL},
	 { "exp_param_gquadLayerMismatchMax_get", _wrap_exp_param_gquadLayerMismatchMax_get, METH_O, NULL},
	 { "exp_param_kT_get", _wrap_exp_param_kT_get, METH_O, NULL},
	 { "exp_param_pf_scale_get", _wrap_exp_param_pf_scale_get, METH_O, NULL},
	 { "exp_param_temperature_get", _wrap_exp_param_temperature_get, METH_O, NULL},
	 { "exp_param_alpha_get", _wrap_exp_param_alpha_get, METH_O, NULL},
	 { "exp_param_model_details_get", _wrap_exp_param_model_details_get, METH_O, NULL},
	 { "exp_param_param_file_get", _wrap_exp_param_param_file_get, METH_O, NULL},
	 { "exp_param_expSaltStack_get", _wrap_exp_param_expSaltStack_get, METH_O, NULL},
	 { "exp_param_expSaltLoop_get", _wrap_exp_param_expSaltLoop_get, METH_O, NULL},
	 { "exp_param_SaltLoopDbl_get", _wrap_exp_param_SaltLoopDbl_get, METH_O, NULL},
	 { "exp_param_SaltMLbase_get", _wrap_exp_param_SaltMLbase_get, METH_O, NULL},
	 { "exp_param_SaltMLintern_get", _wrap_exp_param_SaltMLintern_get, METH_O, NULL},
	 { "exp_param_SaltMLclosing_get", _wrap_exp_param_SaltMLclosing_get, METH_O, NULL},
	 { "exp_param_SaltDPXInit_get", _wrap_exp_param_SaltDPXInit_get, METH_O, NULL},
	 { "new_exp_param", (PyCFunction)(void(*)(void))_wrap_new_exp_param, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"The data structure that contains temperature scaled Boltzmann weights of the energy parameters.  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"id : int  \n"
		"    An identifier for the data structure.  \n"
		"\n"
		"    .. deprecated:: 2.7.2\n"
		"        This attribute will be removed in version 3  \n"
		"\n"
		"expstack : double  \n"
		"\n"
		"exphairpin : double  \n"
		"\n"
		"expbulge : double  \n"
		"\n"
		"expinternal : double  \n"
		"\n"
		"expmismatchExt : double  \n"
		"\n"
		"expmismatchI : double  \n"
		"\n"
		"expmismatch23I : double  \n"
		"\n"
		"expmismatch1nI : double  \n"
		"\n"
		"expmismatchH : double  \n"
		"\n"
		"expmismatchM : double  \n"
		"\n"
		"expdangle5 : double  \n"
		"\n"
		"expdangle3 : double  \n"
		"\n"
		"expint11 : double  \n"
		"\n"
		"expint21 : double  \n"
		"\n"
		"expint22 : double  \n"
		"\n"
		"expninio : double  \n"
		"\n"
		"lxc : double  \n"
		"\n"
		"expMLbase : double  \n"
		"\n"
		"expMLintern : double  \n"
		"\n"
		"expMLclosing : double  \n"
		"\n"
		"expTermAU : double  \n"
		"\n"
		"expDuplexInit : double  \n"
		"\n"
		"exptetra : double  \n"
		"\n"
		"exptri : double  \n"
		"\n"
		"exphex : double  \n"
		"\n"
		"Tetraloops : char  \n"
		"\n"
		"expTriloop : double  \n"
		"\n"
		"Triloops : char  \n"
		"\n"
		"Hexaloops : char  \n"
		"\n"
		"expTripleC : double  \n"
		"\n"
		"expMultipleCA : double  \n"
		"\n"
		"expMultipleCB : double  \n"
		"\n"
		"expgquad : double  \n"
		"\n"
		"expgquadLayerMismatch : double  \n"
		"\n"
		"gquadLayerMismatchMax : unsigned int  \n"
		"\n"
		"kT : double  \n"
		"\n"
		"pf_scale : double  \n"
		"    Scaling factor to avoid over-/underflows.  \n"
		"\n"
		"temperature : double  \n"
		"    Temperature used for loop contribution scaling.  \n"
		"\n"
		"alpha : double  \n"
		"    Scaling factor for the thermodynamic temperature.  \n"
		"\n"
		"    This allows for temperature scaling in Boltzmann factors independently from the energy\n"
		"    contributions. The resulting Boltzmann factors are then computed by :math:`e^{-E/(\\alpha \\cdot\n"
		"    K \\cdot T)}`  \n"
		"\n"
		"model_details : vrna_md_t  \n"
		"    Model details to be used in the recursions.  \n"
		"\n"
		"param_file : char  \n"
		"    The filename the parameters were derived from, or empty string if they represent the default.  \n"
		"\n"
		"expSaltStack : double  \n"
		"\n"
		"expSaltLoop : double  \n"
		"\n"
		"SaltLoopDbl : double  \n"
		"\n"
		"SaltMLbase : int  \n"
		"\n"
		"SaltMLintern : int  \n"
		"\n"
		"SaltMLclosing : int  \n"
		"\n"
		"SaltDPXInit : int  \n"
		"\n"
		""},
	 { "delete_exp_param", _wrap_delete_exp_param, METH_O, NULL},
	 { "exp_param___str__", _wrap_exp_param___str__, METH_O, NULL},
	 { "exp_param_swigregister", exp_param_swigregister, METH_O, NULL},
	 { "exp_param_swiginit", exp_param_swiginit, METH_VARARGS, NULL},
	 { "params_load", (PyCFunction)(void(*)(void))_wrap_params_load, METH_VARARGS|METH_KEYWORDS, "\n"
		"params_load(std::string filename=\"\", unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Load energy parameters from a file.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `params_load`(fname=\"\",\n"
		"    options=RNA.PARAMETER_FORMAT_DEFAULT). Here, the empty filename string indicates to load\n"
		"    default RNA parameters, i.e. this is equivalent to calling RNA.params_load_defaults(). See,\n"
		"    e.g.   :py:func:`RNA.fold_compound.params_load()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fname : const char\n"
		"    The path to the file containing the energy parameters  \n"
		"options : unsigned int\n"
		"    File format bit-mask (usually RNA.PARAMETER_FORMAT_DEFAULT)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load_from_string(), RNA.params_save(), RNA.params_load_defaults(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_RNA_Turner1999(),\n"
		"RNA.params_load_RNA_Andronescu2007(), RNA.params_load_RNA_Langdon2018(),\n"
		"RNA.params_load_RNA_misc_special_hairpins(), RNA.params_load_DNA_Mathews2004(),\n"
		"RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_save", (PyCFunction)(void(*)(void))_wrap_params_save, METH_VARARGS|METH_KEYWORDS, "\n"
		"params_save(std::string filename, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Save energy parameters to a file.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `params_save`(fname,\n"
		"    options=RNA.PARAMETER_FORMAT_DEFAULT). See, e.g.   :py:func:`RNA.params_save()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fname : const char\n"
		"    A filename (path) for the file where the current energy parameters will be written to  \n"
		"options : unsigned int\n"
		"    File format bit-mask (usually RNA.PARAMETER_FORMAT_DEFAULT)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load()  \n"
		"\n"
		""},
	 { "params_load_from_string", (PyCFunction)(void(*)(void))_wrap_params_load_from_string, METH_VARARGS|METH_KEYWORDS, "\n"
		"params_load_from_string(std::string parameters, std::string name=\"\", unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Load energy paramters from string.  \n"
		"\n"
		"The string must follow the default energy parameter file convention! The optional `name` argument\n"
		"allows one to specify a name for the parameter set which is stored internally.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `params_load_from_string`(string, name=\"\",\n"
		"    options=RNA.PARAMETER_FORMAT_DEFAULT). See, e.g.   :py:func:`RNA.params_load_from_string()` in\n"
		"    the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    A 0-terminated string containing energy parameters  \n"
		"name : const char *\n"
		"    A name for the parameter set in `string` (Maybe `NULL`)  \n"
		"options : unsigned int\n"
		"    File format bit-mask (usually RNA.PARAMETER_FORMAT_DEFAULT)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_save(), RNA.params_load_defaults(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_RNA_Turner1999(),\n"
		"RNA.params_load_RNA_Andronescu2007(), RNA.params_load_RNA_Langdon2018(),\n"
		"RNA.params_load_RNA_misc_special_hairpins(), RNA.params_load_DNA_Mathews2004(),\n"
		"RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_load_RNA_Turner2004", _wrap_params_load_RNA_Turner2004, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Load Turner 2004 RNA energy parameter set.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `params_load_RNA_Turner2004()`. See, e.g.\n"
		"    :py:func:`RNA.params_load_RNA_Turner2004()` in the :doc:`/api_python`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function also resets the default geometric parameters as stored in RNA.md() to those of RNA.\n"
		"Only subsequently initialized RNA.md() structures will be affected by this change.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_load_from_string(), RNA.params_save(), RNA.params_load_defaults(),\n"
		"RNA.params_load_RNA_Turner1999(), RNA.params_load_RNA_Andronescu2007(),\n"
		"RNA.params_load_RNA_Langdon2018(), RNA.params_load_RNA_misc_special_hairpins(),\n"
		"RNA.params_load_DNA_Mathews2004(), RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_load_RNA_Turner1999", _wrap_params_load_RNA_Turner1999, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Load Turner 1999 RNA energy parameter set.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `params_load_RNA_Turner1999()`. See, e.g.\n"
		"    :py:func:`RNA.params_load_RNA_Turner1999()` in the :doc:`/api_python`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function also resets the default geometric parameters as stored in RNA.md() to those of RNA.\n"
		"Only subsequently initialized RNA.md() structures will be affected by this change.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_load_from_string(), RNA.params_save(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_defaults(),\n"
		"RNA.params_load_RNA_Andronescu2007(), RNA.params_load_RNA_Langdon2018(),\n"
		"RNA.params_load_RNA_misc_special_hairpins(), RNA.params_load_DNA_Mathews2004(),\n"
		"RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_load_RNA_Andronescu2007", _wrap_params_load_RNA_Andronescu2007, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Load Andronsecu 2007 RNA energy parameter set.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `params_load_RNA_Andronescu2007()`. See, e.g.\n"
		"    :py:func:`RNA.params_load_RNA_Andronescu2007()` in the :doc:`/api_python`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function also resets the default geometric parameters as stored in RNA.md() to those of RNA.\n"
		"Only subsequently initialized RNA.md() structures will be affected by this change.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_load_from_string(), RNA.params_save(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_RNA_Turner1999(), RNA.params_load_defaults(),\n"
		"RNA.params_load_RNA_Langdon2018(), RNA.params_load_RNA_misc_special_hairpins(),\n"
		"RNA.params_load_DNA_Mathews2004(), RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_load_RNA_Langdon2018", _wrap_params_load_RNA_Langdon2018, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Load Langdon 2018 RNA energy parameter set.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `params_load_RNA_Langdon2018()`. See, e.g.\n"
		"    :py:func:`RNA.params_load_RNA_Langdon2018()` in the :doc:`/api_python`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function also resets the default geometric parameters as stored in RNA.md() to those of RNA.\n"
		"Only subsequently initialized RNA.md() structures will be affected by this change.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_load_from_string(), RNA.params_save(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_RNA_Turner1999(),\n"
		"RNA.params_load_RNA_Andronescu2007(), RNA.params_load_defaults(),\n"
		"RNA.params_load_RNA_misc_special_hairpins(), RNA.params_load_DNA_Mathews2004(),\n"
		"RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_load_RNA_misc_special_hairpins", _wrap_params_load_RNA_misc_special_hairpins, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Load Misc Special Hairpin RNA energy parameter set.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `params_load_RNA_misc_special_hairpins()`. See, e.g.\n"
		"    :py:func:`RNA.params_load_RNA_misc_special_hairpins()` in the :doc:`/api_python`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function also resets the default geometric parameters as stored in RNA.md() to those of RNA.\n"
		"Only subsequently initialized RNA.md() structures will be affected by this change.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_load_from_string(), RNA.params_save(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_RNA_Turner1999(),\n"
		"RNA.params_load_RNA_Andronescu2007(), RNA.params_load_RNA_Langdon2018(),\n"
		"RNA.params_load_defaults(), RNA.params_load_DNA_Mathews2004(), RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_load_DNA_Mathews2004", _wrap_params_load_DNA_Mathews2004, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Load Mathews 2004 DNA energy parameter set.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `params_load_DNA_Mathews2004()`. See, e.g.\n"
		"    :py:func:`RNA.params_load_DNA_Mathews2004()` in the :doc:`/api_python`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function also resets the default geometric parameters as stored in RNA.md() to those of DNA.\n"
		"Only subsequently initialized RNA.md() structures will be affected by this change.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_load_from_string(), RNA.params_save(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_RNA_Turner1999(),\n"
		"RNA.params_load_RNA_Andronescu2007(), RNA.params_load_RNA_Langdon2018(),\n"
		"RNA.params_load_RNA_misc_special_hairpins(), RNA.params_load_defaults(),\n"
		"RNA.params_load_DNA_Mathews1999()  \n"
		"\n"
		""},
	 { "params_load_DNA_Mathews1999", _wrap_params_load_DNA_Mathews1999, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Load Mathews 1999 DNA energy parameter set.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `params_load_DNA_Mathews1999()`. See, e.g.\n"
		"    :py:func:`RNA.params_load_DNA_Mathews1999()` in the :doc:`/api_python`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on success, 0 on failure  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function also resets the default geometric parameters as stored in RNA.md() to those of DNA.\n"
		"Only subsequently initialized RNA.md() structures will be affected by this change.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.params_load(), RNA.params_load_from_string(), RNA.params_save(),\n"
		"RNA.params_load_RNA_Turner2004(), RNA.params_load_RNA_Turner1999(),\n"
		"RNA.params_load_RNA_Andronescu2007(), RNA.params_load_RNA_Langdon2018(),\n"
		"RNA.params_load_RNA_misc_special_hairpins(), RNA.params_load_DNA_Mathews2004(),\n"
		"RNA.params_load_defaults()  \n"
		"\n"
		""},
	 { "last_parameter_file", _wrap_last_parameter_file, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Get the file name of the parameter file that was most recently loaded.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"const char *  \n"
		"    The file name of the last parameter file, or NULL if parameters are still at defaults  \n"
		"\n"
		""},
	 { "read_parameter_file", (PyCFunction)(void(*)(void))_wrap_read_parameter_file, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Read energy parameters from a file.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.params_load() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fname : const char\n"
		"    The path to the file containing the energy parameters  \n"
		"\n"
		""},
	 { "write_parameter_file", (PyCFunction)(void(*)(void))_wrap_write_parameter_file, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Write energy parameters to a file.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.params_save() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fname : const char\n"
		"    A filename (path) for the file where the current energy parameters will be written to  \n"
		"\n"
		""},
	 { "gettype", (PyCFunction)(void(*)(void))_wrap_gettype, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "settype", (PyCFunction)(void(*)(void))_wrap_settype, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "salt_loop", (PyCFunction)(void(*)(void))_wrap_salt_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get salt correction for a loop at a given salt concentration and temperature.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"L : int\n"
		"    backbone number in loop  \n"
		"salt : double\n"
		"    salt concentration (M)  \n"
		"T : double\n"
		"    absolute temperature (K)  \n"
		"backbonelen : double\n"
		"    Backbone Length, phosphate-to-phosphate distance (typically 6 for RNA, 6.76 for DNA)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"double  \n"
		"    Salt correction for loop in dcal/mol  \n"
		"\n"
		""},
	 { "salt_loop_int", (PyCFunction)(void(*)(void))_wrap_salt_loop_int, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get salt correction for a loop at a given salt concentration and temperature.  \n"
		"\n"
		"This functions is same as RNA.salt_loop but returns rounded salt correction in integer  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"L : int\n"
		"    backbone number in loop  \n"
		"salt : double\n"
		"    salt concentration (M)  \n"
		"T : double\n"
		"    absolute temperature (K)  \n"
		"backbonelen : double\n"
		"    Backbone Length, phosphate-to-phosphate distance (typically 6 for RNA, 6.76 for DNA)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Rounded salt correction for loop in dcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.salt_loop  \n"
		"\n"
		""},
	 { "salt_stack", (PyCFunction)(void(*)(void))_wrap_salt_stack, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get salt correction for a stack at a given salt concentration and temperature.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"salt : double\n"
		"    salt concentration (M)  \n"
		"T : double\n"
		"    absolute temperature (K)  \n"
		"hrise : double\n"
		"    Helical Rise (typically 2.8 for RNA, 3.4 for DNA)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Rounded salt correction for stack in dcal/mol  \n"
		"\n"
		""},
	 { "salt_ml", (PyCFunction)(void(*)(void))_wrap_salt_ml, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Fit linear function to loop salt correction.  \n"
		"\n"
		"For a given range of loop size (backbone number), we perform a linear fitting on loop salt\n"
		"correction  \n"
		"\n"
		".. math::\n"
		"\n"
		"  \\text{Loop correction} \\approx m \\cdot L + b.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"saltLoop : double\n"
		"    List of loop salt correction of size from 1  \n"
		"lower : int\n"
		"    Define the size lower bound for fitting  \n"
		"upper : int\n"
		"    Define the size upper bound for fitting  \n"
		"m : int *\n"
		"    pointer to store the parameter m in fitting result  \n"
		"b : int *\n"
		"    pointer to store the parameter b in fitting result  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.salt_loop()  \n"
		"\n"
		""},
	 { "salt_duplex_init", (PyCFunction)(void(*)(void))_wrap_salt_duplex_init, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get salt correction for duplex initialization at a given salt concentration.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"md : RNA.md() *\n"
		"    Model details data structure that specfifies salt concentration in buffer (M)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Rounded correction for duplex initialization in dcal/mol  \n"
		"\n"
		""},
	 { "md_temperature_set", _wrap_md_temperature_set, METH_VARARGS, NULL},
	 { "md_temperature_get", _wrap_md_temperature_get, METH_O, NULL},
	 { "md_betaScale_set", _wrap_md_betaScale_set, METH_VARARGS, NULL},
	 { "md_betaScale_get", _wrap_md_betaScale_get, METH_O, NULL},
	 { "md_pf_smooth_set", _wrap_md_pf_smooth_set, METH_VARARGS, NULL},
	 { "md_pf_smooth_get", _wrap_md_pf_smooth_get, METH_O, NULL},
	 { "md_dangles_set", _wrap_md_dangles_set, METH_VARARGS, NULL},
	 { "md_dangles_get", _wrap_md_dangles_get, METH_O, NULL},
	 { "md_special_hp_set", _wrap_md_special_hp_set, METH_VARARGS, NULL},
	 { "md_special_hp_get", _wrap_md_special_hp_get, METH_O, NULL},
	 { "md_noLP_set", _wrap_md_noLP_set, METH_VARARGS, NULL},
	 { "md_noLP_get", _wrap_md_noLP_get, METH_O, NULL},
	 { "md_noGU_set", _wrap_md_noGU_set, METH_VARARGS, NULL},
	 { "md_noGU_get", _wrap_md_noGU_get, METH_O, NULL},
	 { "md_noGUclosure_set", _wrap_md_noGUclosure_set, METH_VARARGS, NULL},
	 { "md_noGUclosure_get", _wrap_md_noGUclosure_get, METH_O, NULL},
	 { "md_logML_set", _wrap_md_logML_set, METH_VARARGS, NULL},
	 { "md_logML_get", _wrap_md_logML_get, METH_O, NULL},
	 { "md_circ_set", _wrap_md_circ_set, METH_VARARGS, NULL},
	 { "md_circ_get", _wrap_md_circ_get, METH_O, NULL},
	 { "md_circ_penalty_set", _wrap_md_circ_penalty_set, METH_VARARGS, NULL},
	 { "md_circ_penalty_get", _wrap_md_circ_penalty_get, METH_O, NULL},
	 { "md_gquad_set", _wrap_md_gquad_set, METH_VARARGS, NULL},
	 { "md_gquad_get", _wrap_md_gquad_get, METH_O, NULL},
	 { "md_uniq_ML_set", _wrap_md_uniq_ML_set, METH_VARARGS, NULL},
	 { "md_uniq_ML_get", _wrap_md_uniq_ML_get, METH_O, NULL},
	 { "md_energy_set_set", _wrap_md_energy_set_set, METH_VARARGS, NULL},
	 { "md_energy_set_get", _wrap_md_energy_set_get, METH_O, NULL},
	 { "md_backtrack_set", _wrap_md_backtrack_set, METH_VARARGS, NULL},
	 { "md_backtrack_get", _wrap_md_backtrack_get, METH_O, NULL},
	 { "md_backtrack_type_set", _wrap_md_backtrack_type_set, METH_VARARGS, NULL},
	 { "md_backtrack_type_get", _wrap_md_backtrack_type_get, METH_O, NULL},
	 { "md_compute_bpp_set", _wrap_md_compute_bpp_set, METH_VARARGS, NULL},
	 { "md_compute_bpp_get", _wrap_md_compute_bpp_get, METH_O, NULL},
	 { "md_nonstandards_set", _wrap_md_nonstandards_set, METH_VARARGS, NULL},
	 { "md_nonstandards_get", _wrap_md_nonstandards_get, METH_O, NULL},
	 { "md_max_bp_span_set", _wrap_md_max_bp_span_set, METH_VARARGS, NULL},
	 { "md_max_bp_span_get", _wrap_md_max_bp_span_get, METH_O, NULL},
	 { "md_min_loop_size_set", _wrap_md_min_loop_size_set, METH_VARARGS, NULL},
	 { "md_min_loop_size_get", _wrap_md_min_loop_size_get, METH_O, NULL},
	 { "md_window_size_set", _wrap_md_window_size_set, METH_VARARGS, NULL},
	 { "md_window_size_get", _wrap_md_window_size_get, METH_O, NULL},
	 { "md_oldAliEn_set", _wrap_md_oldAliEn_set, METH_VARARGS, NULL},
	 { "md_oldAliEn_get", _wrap_md_oldAliEn_get, METH_O, NULL},
	 { "md_ribo_set", _wrap_md_ribo_set, METH_VARARGS, NULL},
	 { "md_ribo_get", _wrap_md_ribo_get, METH_O, NULL},
	 { "md_cv_fact_set", _wrap_md_cv_fact_set, METH_VARARGS, NULL},
	 { "md_cv_fact_get", _wrap_md_cv_fact_get, METH_O, NULL},
	 { "md_nc_fact_set", _wrap_md_nc_fact_set, METH_VARARGS, NULL},
	 { "md_nc_fact_get", _wrap_md_nc_fact_get, METH_O, NULL},
	 { "md_sfact_set", _wrap_md_sfact_set, METH_VARARGS, NULL},
	 { "md_sfact_get", _wrap_md_sfact_get, METH_O, NULL},
	 { "md_rtype_get", _wrap_md_rtype_get, METH_O, NULL},
	 { "md_alias_get", _wrap_md_alias_get, METH_O, NULL},
	 { "md_pair_get", _wrap_md_pair_get, METH_O, NULL},
	 { "md_salt_set", _wrap_md_salt_set, METH_VARARGS, NULL},
	 { "md_salt_get", _wrap_md_salt_get, METH_O, NULL},
	 { "md_saltMLLower_set", _wrap_md_saltMLLower_set, METH_VARARGS, NULL},
	 { "md_saltMLLower_get", _wrap_md_saltMLLower_get, METH_O, NULL},
	 { "md_saltMLUpper_set", _wrap_md_saltMLUpper_set, METH_VARARGS, NULL},
	 { "md_saltMLUpper_get", _wrap_md_saltMLUpper_get, METH_O, NULL},
	 { "md_saltDPXInit_set", _wrap_md_saltDPXInit_set, METH_VARARGS, NULL},
	 { "md_saltDPXInit_get", _wrap_md_saltDPXInit_get, METH_O, NULL},
	 { "md_saltDPXInitFact_set", _wrap_md_saltDPXInitFact_set, METH_VARARGS, NULL},
	 { "md_saltDPXInitFact_get", _wrap_md_saltDPXInitFact_get, METH_O, NULL},
	 { "md_helical_rise_set", _wrap_md_helical_rise_set, METH_VARARGS, NULL},
	 { "md_helical_rise_get", _wrap_md_helical_rise_get, METH_O, NULL},
	 { "md_backbone_length_set", _wrap_md_backbone_length_set, METH_VARARGS, NULL},
	 { "md_backbone_length_get", _wrap_md_backbone_length_get, METH_O, NULL},
	 { "md_circ_alpha0_set", _wrap_md_circ_alpha0_set, METH_VARARGS, NULL},
	 { "md_circ_alpha0_get", _wrap_md_circ_alpha0_get, METH_O, NULL},
	 { "new_md", (PyCFunction)(void(*)(void))_wrap_new_md, METH_VARARGS|METH_KEYWORDS, "\n"
		"new_md(double temperature=vrna_md_defaults_temperature_get(), double betaScale=vrna_md_defaults_betaScale_get(), int pf_smooth=vrna_md_defaults_pf_smooth_get(), int dangles=vrna_md_defaults_dangles_get(), int special_hp=vrna_md_defaults_special_hp_get(), int noLP=vrna_md_defaults_noLP_get(), int noGU=vrna_md_defaults_noGU_get(), int noGUclosure=vrna_md_defaults_noGUclosure_get(), int logML=vrna_md_defaults_logML_get(), int circ=vrna_md_defaults_circ_get(), int circ_penalty=vrna_md_defaults_circ_penalty_get(), int gquad=vrna_md_defaults_gquad_get(), int uniq_ML=vrna_md_defaults_uniq_ML_get(), int energy_set=vrna_md_defaults_energy_set_get(), int backtrack=vrna_md_defaults_backtrack_get(), char backtrack_type=vrna_md_defaults_backtrack_type_get(), int compute_bpp=vrna_md_defaults_compute_bpp_get(), int max_bp_span=vrna_md_defaults_max_bp_span_get(), int min_loop_size=vrna_md_defaults_min_loop_size_get(), int window_size=vrna_md_defaults_window_size_get(), int oldAliEn=vrna_md_defaults_oldAliEn_get(), int ribo=vrna_md_defaults_ribo_get(), double cv_fact=vrna_md_defaults_cv_fact_get(), double nc_fact=vrna_md_defaults_nc_fact_get(), double sfact=vrna_md_defaults_sfact_get(), double salt=vrna_md_defaults_salt_get(), int saltMLLower=vrna_md_defaults_saltMLLower_get(), int saltMLUpper=vrna_md_defaults_saltMLUpper_get(), int saltDPXInit=vrna_md_defaults_saltDPXInit_get(), float saltDPXInitFact=vrna_md_defaults_saltDPXInitFact_get(), float helical_rise=vrna_md_defaults_helical_rise_get(), float backbone_length=vrna_md_defaults_backbone_length_get()) -> md\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"temperature: double\n"
		"     The temperature in degree C used to scale the thermodynamic parameters\n"
		"betaScale: double\n"
		"     A scaling factor for the thermodynamic temperature of the Boltzmann factors.\n"
		"pf_smooth: int\n"
		"     A flag specifying whether energies in Boltzmann factors need to be smoothed.\n"
		"dangles: int\n"
		"     Specifies the dangle model used in any energy evaluation (0, 1, 2, or 3)\n"
		"special_hp: int\n"
		"     Include special hairpin contributions for tri, tetra and hexaloops.\n"
		"noLP: int\n"
		"     Only consider canonical structures, i.e. no 'lonely' base pairs.\n"
		"noGU: int\n"
		"     Do not allow GU pairs.\n"
		"noGUclosure: int\n"
		"     Do not allow loops to be closed by GU pair.\n"
		"logML: int\n"
		"     Use logarithmic scaling for multiloops.\n"
		"circ: int\n"
		"     Assume RNA to be circular instead of linear.\n"
		"circ_penalty: int\n"
		"     Add entropic penalty for unpaired chain in circular RNAs.\n"
		"gquad: int\n"
		"     Include G-quadruplexes in structure prediction.\n"
		"uniq_ML: int\n"
		"     Flag to ensure unique multi-branch loop decomposition during folding.\n"
		"energy_set: int\n"
		"     Specifies the energy set that defines set of compatible base pairs.\n"
		"backtrack: int\n"
		"     Specifies whether or not secondary structures should be backtraced.\n"
		"backtrack_type: char\n"
		"     Specifies in which matrix to backtrack.\n"
		"compute_bpp: int\n"
		"     Specifies whether or not backward recursions for base pair probability (bpp) computation will be performed.\n"
		"max_bp_span: int\n"
		"     maximum allowed base pair span\n"
		"min_loop_size: int\n"
		"     Minimum size of hairpin loops.\n"
		"window_size: int\n"
		"     Size of the sliding window for locally optimal structure prediction.\n"
		"oldAliEn: int\n"
		"     Use old alifold energy model.\n"
		"ribo: int\n"
		"     Use ribosum scoring table in alifold energy model.\n"
		"cv_fact: double\n"
		"     Co-variance scaling factor for consensus structure prediction.\n"
		"nc_fact: double\n"
		"     Scaling factor to weight co-variance contributions of non-canonical pairs.\n"
		"sfact: double\n"
		"     Scaling factor for partition function scaling.\n"
		"salt: double\n"
		"     Salt (monovalent) concentration (M) in buffer.\n"
		"saltMLLower: int\n"
		"     Lower bound of multiloop size to use in loop salt correction linear fitting.\n"
		"saltMLUpper: int\n"
		"     Upper bound of multiloop size to use in loop salt correction linear fitting.\n"
		"saltDPXInit: int\n"
		"     User-provided salt correction for duplex initialization (in dcal/mol).\n"
		"saltDPXInitFact: float\n"
		"helical_rise: float\n"
		"backbone_length: float\n"
		"\n"
		"\n"
		".. note::\n"
		"\n"
		"  Default parameters can be modified by directly setting any of the following\n"
		"  global variables (accessible as `RNA.cvar.variable` where `variable` is the\n"
		"  variable name. Internally, getting/setting default parameters using their global variable\n"
		"  representative translates into calls of the corresponding getter and setter functions,\n"
		"  which consequently have not been wrapped directly in the scripting language interface(s):\n"
		"\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | global variable | `C getter`                                      | `C setter`                                  |\n"
		"  +=================+=================================================+=============================================+\n"
		"  | temperature     | :c:func:`vrna_md_defaults_temperature_get()`    | :c:func:`vrna_md_defaults_temperature()`    |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | dangles         | :c:func:`vrna_md_defaults_dangles_get()`        | :c:func:`vrna_md_defaults_dangles()`        |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | betaScale       | :c:func:`vrna_md_defaults_betaScale_get()`      | :c:func:`vrna_md_defaults_betaScale()`      |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | tetra_loop      | this is an alias of variable `special_hp`       |                                             |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | special_hp      | :c:func:`vrna_md_defaults_special_hp_get()`     | :c:func:`vrna_md_defaults_special_hp()`     |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | noLonelyPairs   | this is an alias of variable `noLP`             |                                             |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | noLP            | :c:func:`vrna_md_defaults_noLP_get()`           | :c:func:`vrna_md_defaults_noLP()`           |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | noGU            | :c:func:`vrna_md_defaults_noGU_get()`           | :c:func:`vrna_md_defaults_noGU()`           |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | no_closingGU    | this is an alias of variable `noGUclosure`      |                                             |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | noGUclosure     | :c:func:`vrna_md_defaults_noGUclosure_get()`    | :c:func:`vrna_md_defaults_noGUclosure()`    |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | logML           | :c:func:`vrna_md_defaults_logML_get()`          | :c:func:`vrna_md_defaults_logML()`          |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | circ            | :c:func:`vrna_md_defaults_circ_get()`           | :c:func:`vrna_md_defaults_circ()`           |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | gquad           | :c:func:`vrna_md_defaults_gquad_get()`          | :c:func:`vrna_md_defaults_gquad()`          |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | uniq_ML         | :c:func:`vrna_md_defaults_uniq_ML_get()`        | :c:func:`vrna_md_defaults_uniq_ML()`        |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | energy_set      | :c:func:`vrna_md_defaults_energy_set_get()`     | :c:func:`vrna_md_defaults_energy_set()`     |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | backtrack       | :c:func:`vrna_md_defaults_backtrack_get()`      | :c:func:`vrna_md_defaults_backtrack()`      |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | backtrack_type  | :c:func:`vrna_md_defaults_backtrack_type_get()` | :c:func:`vrna_md_defaults_backtrack_type()` |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | do_backtrack    | this is an alias of variable `compute_bpp`      |                                             |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | compute_bpp     | :c:func:`vrna_md_defaults_compute_bpp_get()`    | :c:func:`vrna_md_defaults_compute_bpp()`    |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | max_bp_span     | :c:func:`vrna_md_defaults_max_bp_span_get()`    | :c:func:`vrna_md_defaults_max_bp_span()`    |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | min_loop_size   | :c:func:`vrna_md_defaults_min_loop_size_get()`  | :c:func:`vrna_md_defaults_min_loop_size()`  |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | window_size     | :c:func:`vrna_md_defaults_window_size_get()`    | :c:func:`vrna_md_defaults_window_size()`    |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | oldAliEn        | :c:func:`vrna_md_defaults_oldAliEn_get()`       | :c:func:`vrna_md_defaults_oldAliEn()`       |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | ribo            | :c:func:`vrna_md_defaults_ribo_get()`           | :c:func:`vrna_md_defaults_ribo()`           |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | cv_fact         | :c:func:`vrna_md_defaults_cv_fact_get()`        | :c:func:`vrna_md_defaults_cv_fact()`        |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | nc_fact         | :c:func:`vrna_md_defaults_nc_fact_get()`        | :c:func:`vrna_md_defaults_nc_fact()`        |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"  | sfact           | :c:func:`vrna_md_defaults_sfact_get()`          | :c:func:`vrna_md_defaults_sfact()`          |\n"
		"  +-----------------+-------------------------------------------------+---------------------------------------------+\n"
		"\n"
		""},
	 { "delete_md", _wrap_delete_md, METH_O, NULL},
	 { "md_reset", _wrap_md_reset, METH_O, "\n"
		"\n"
		"\n"
		"Apply default model details to a provided RNA.md() data structure.  \n"
		"\n"
		"Use this function to initialize a RNA.md() data structure with its default values  \n"
		"\n"
		"Parameters\n"
		"----------  \n"
		"\n"
		""},
	 { "md_set_from_globals", _wrap_md_set_from_globals, METH_O, NULL},
	 { "md_option_string", _wrap_md_option_string, METH_O, "\n"
		"\n"
		"\n"
		"Get a corresponding commandline parameter string of the options in a RNA.md().  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is not threadsafe!  \n"
		"\n"
		""},
	 { "md___str__", _wrap_md___str__, METH_O, NULL},
	 { "md_swigregister", md_swigregister, METH_O, NULL},
	 { "md_swiginit", md_swiginit, METH_VARARGS, NULL},
	 { "init_rand", _wrap_init_rand, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Initialize the random number generator with a pre-defined seed.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as an overloaded function **init_rand()** where the argument `seed`\n"
		"    is optional. See, e.g.   :py:func:`RNA.init_rand()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seed : unsigned int\n"
		"    The seed for the random number generator  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.init_rand(), RNA.urn()  \n"
		"\n"
		""},
	 { "urn", _wrap_urn, METH_NOARGS, "\n"
		"\n"
		"\n"
		"get a random number from [0..1]  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"double  \n"
		"    A random number in range [0..1]  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.int_urn(), RNA.init_rand(), RNA.init_rand_seed()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Usually implemented by calling *erand48()*.  \n"
		"\n"
		""},
	 { "int_urn", (PyCFunction)(void(*)(void))_wrap_int_urn, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Generates a pseudo random integer in a specified range.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"from : int\n"
		"    The first number in range  \n"
		"to : int\n"
		"    The last number in range  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    A pseudo random number in range [from, to]  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.urn(), RNA.init_rand()  \n"
		"\n"
		""},
	 { "hamming", (PyCFunction)(void(*)(void))_wrap_hamming, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate hamming distance between two sequences.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s1 : const char *\n"
		"    The first sequence  \n"
		"s2 : const char *\n"
		"    The second sequence  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The hamming distance between s1 and s2  \n"
		"\n"
		""},
	 { "hamming_bound", (PyCFunction)(void(*)(void))_wrap_hamming_bound, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate hamming distance between two sequences up to a specified length.  \n"
		"\n"
		"This function is similar to RNA.hamming_distance() but instead of comparing both sequences up to\n"
		"their actual length only the first 'n' characters are taken into account  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s1 : const char *\n"
		"    The first sequence  \n"
		"s2 : const char *\n"
		"    The second sequence  \n"
		"n : int\n"
		"    The length of the subsequences to consider (starting from the 5' end)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The hamming distance between s1 and s2  \n"
		"\n"
		""},
	 { "encode_seq", (PyCFunction)(void(*)(void))_wrap_encode_seq, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "strtrim", (PyCFunction)(void(*)(void))_wrap_strtrim, METH_VARARGS|METH_KEYWORDS, "\n"
		"strtrim(char * seq_mutable, char const * delimiters=None, unsigned int keep=0, unsigned int options=) -> unsigned int\n"
		"\n"
		"\n"
		"Trim a string by removing (multiple) occurences of a particular character.  \n"
		"\n"
		"This function removes (multiple) consecutive occurences of a set of characters (`delimiters`) within\n"
		"an input string. It may be used to remove leading and/or trailing whitespaces or to restrict the\n"
		"maximum number of consecutive occurences of the delimiting characters `delimiters`. Setting `keep=0`\n"
		"removes all occurences, while other values reduce multiple consecutive occurences to at most `keep`\n"
		"delimiters. This might be useful if one would like to reduce multiple whitespaces to a single one,\n"
		"or to remove empty fields within a comma-separated value string.  \n"
		"\n"
		"The parameter `delimiters` may be a pointer to a 0-terminated char string containing a set of any\n"
		"ASCII character. If *NULL* is passed as delimiter set or an empty char string, all whitespace\n"
		"characters are trimmed. The `options` parameter is a bit vector that specifies which part of the\n"
		"string should undergo trimming. The implementation distinguishes the leading (RNA.TRIM_LEADING),\n"
		"trailing (RNA.TRIM_TRAILING), and in-between (RNA.TRIM_IN_BETWEEN) part with respect to the\n"
		"delimiter set. Combinations of these parts can be specified by using logical-or operator.  \n"
		"\n"
		"The following example code removes all leading and trailing whitespace characters from the input\n"
		"string:  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    Since many scripting languages treat strings as immutable objects, this function does not modify\n"
		"    the input string directly. Instead, it returns the modified string as second return value,\n"
		"    together with the number of removed delimiters.  \n"
		"\n"
		"    The scripting language interface provides an overloaded version of this function, with default\n"
		"    parameters `delimiters=NULL`, `keep=0`, and `options=RNA.TRIM_DEFAULT`. See, e.g.\n"
		"    :py:func:`RNA.strtrim()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : char *\n"
		"    The '\\0'-terminated input string to trim  \n"
		"delimiters : const char *\n"
		"    The delimiter characters as 0-terminated char array (or *NULL*)  \n"
		"keep : unsigned int\n"
		"    The maximum number of consecutive occurences of the delimiter in the output string  \n"
		"options : unsigned int\n"
		"    The option bit vector specifying the mode of operation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int  \n"
		"    The number of delimiters removed from the string  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.TRIM_LEADING, RNA.TRIM_TRAILING, RNA.TRIM_IN_BETWEEN, RNA.TRIM_SUBST_BY_FIRST,\n"
		"RNA.TRIM_DEFAULT, RNA.TRIM_ALL  \n"
		"\n"
		"Note\n"
		"----\n"
		"The delimiter always consists of a single character from the set of characters provided. In case of\n"
		"alternative delimiters and non-null `keep` parameter, the first `keep` delimiters are preserved\n"
		"within the string. Use RNA.TRIM_SUBST_BY_FIRST to substitute all remaining delimiting characters\n"
		"with the first from the `delimiters` list.  \n"
		"\n"
		""},
	 { "str_to_dbl_array", (PyCFunction)(void(*)(void))_wrap_str_to_dbl_array, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "random_string", (PyCFunction)(void(*)(void))_wrap_random_string, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Create a random string using characters from a specified symbol set.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"l : int\n"
		"    The length of the sequence  \n"
		"symbols : const char\n"
		"    The symbol set  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A random string of length 'l' containing characters from the symbolset  \n"
		"\n"
		""},
	 { "hamming_distance", (PyCFunction)(void(*)(void))_wrap_hamming_distance, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "hamming_distance_bound", (PyCFunction)(void(*)(void))_wrap_hamming_distance_bound, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ep_i_set", _wrap_ep_i_set, METH_VARARGS, NULL},
	 { "ep_i_get", _wrap_ep_i_get, METH_O, NULL},
	 { "ep_j_set", _wrap_ep_j_set, METH_VARARGS, NULL},
	 { "ep_j_get", _wrap_ep_j_get, METH_O, NULL},
	 { "ep_p_set", _wrap_ep_p_set, METH_VARARGS, NULL},
	 { "ep_p_get", _wrap_ep_p_get, METH_O, NULL},
	 { "ep_type_set", _wrap_ep_type_set, METH_VARARGS, NULL},
	 { "ep_type_get", _wrap_ep_type_get, METH_O, NULL},
	 { "new_ep", (PyCFunction)(void(*)(void))_wrap_new_ep, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Data structure representing a single entry of an element probability list (e.g. list of pair\n"
		"probabilities).  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plist(), RNA.fold_compound.plist_from_probs(), RNA.db_from_plist(),  \n"
		"RNA.PLIST_TYPE_BASEPAIR, RNA.PLIST_TYPE_GQUAD, RNA.PLIST_TYPE_H_MOTIF, RNA.PLIST_TYPE_I_MOTIF,\n"
		"RNA.PLIST_TYPE_UD_MOTIF, RNA.PLIST_TYPE_STACK  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"i : int  \n"
		"    Start position (usually 5' nucleotide that starts the element, e.g. base pair).  \n"
		"\n"
		"j : int  \n"
		"    End position (usually 3' nucleotide that ends the element, e.g. base pair).  \n"
		"\n"
		"p : float  \n"
		"    Probability of the element.  \n"
		"\n"
		"type : int  \n"
		"    Type of the element.  \n"
		"\n"
		""},
	 { "ep___str__", _wrap_ep___str__, METH_O, NULL},
	 { "delete_ep", _wrap_delete_ep, METH_O, NULL},
	 { "ep_swigregister", ep_swigregister, METH_O, NULL},
	 { "ep_swiginit", ep_swiginit, METH_VARARGS, NULL},
	 { "pack_structure", (PyCFunction)(void(*)(void))_wrap_pack_structure, METH_VARARGS|METH_KEYWORDS, "pack_structure(char const * s) -> char *"},
	 { "unpack_structure", (PyCFunction)(void(*)(void))_wrap_unpack_structure, METH_VARARGS|METH_KEYWORDS, "unpack_structure(char const * packed) -> char *"},
	 { "db_from_ptable", _wrap_db_from_ptable, METH_VARARGS, "\n"
		"db_from_ptable(IntVector pt) -> char\n"
		"db_from_ptable(varArrayShort pt) -> char *\n"
		"\n"
		"\n"
		"Convert a pair table into dot-parenthesis notation.  \n"
		"\n"
		"This function also converts pair table formatted structures that contain pseudoknots. Non-nested\n"
		"base pairs result in additional pairs of parenthesis and brackets within the resulting dot-\n"
		"parenthesis string. The following pairs are awailable: (), []. {}. <>, as well as pairs of matching\n"
		"upper-/lower-case characters from the alphabet A-Z.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : const short *\n"
		"    The pair table to be copied  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A char pointer to the dot-bracket string  \n"
		"\n"
		"Note\n"
		"----\n"
		"In cases where the level of non-nested base pairs exceeds the maximum number of 30 different base\n"
		"pair indicators (4 parenthesis/brackets, 26 matching characters), a warning is printed and the\n"
		"remaining base pairs are left out from the conversion.  \n"
		"\n"
		""},
	 { "db_flatten", _wrap_db_flatten, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Substitute pairs of brackets in a string with parenthesis.  \n"
		"\n"
		"This function can be used to replace brackets of unusual types, such as angular brackets `<>` , to\n"
		"dot-bracket format. The `options` parameter is used tpo specify which types of brackets will be\n"
		"replaced by round parenthesis ``() .  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function flattens an input structure string in-place! The second parameter is optional and\n"
		"    defaults to RNA.BRACKETS_DEFAULT.  \n"
		"\n"
		"    An overloaded version of this function exists, where an additional second parameter can be\n"
		"    passed to specify the target brackets, i.e. the type of matching pair characters all brackets\n"
		"    will be flattened to. Therefore, in the scripting language interface this function is a\n"
		"    replacement for RNA.db_flatten_to(). See, e.g.   :py:func:`RNA.db_flatten()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : char *\n"
		"    The structure string where brackets are flattened in-place  \n"
		"options : unsigned int\n"
		"    A bitmask to specify which types of brackets should be flattened out  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.db_flatten_to(), RNA.BRACKETS_RND, RNA.BRACKETS_ANG, RNA.BRACKETS_CLY, RNA.BRACKETS_SQR,\n"
		"RNA.BRACKETS_DEFAULT  \n"
		"\n"
		""},
	 { "db_from_WUSS", (PyCFunction)(void(*)(void))_wrap_db_from_WUSS, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Convert a WUSS annotation string to dot-bracket format.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"wuss : const char *\n"
		"    The input string in WUSS notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A dot-bracket notation of the input secondary structure  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function flattens all brackets, and treats pseudo-knots annotated by matching pairs of\n"
		"upper/lowercase letters as unpaired nucleotides  \n"
		"\n"
		""},
	 { "abstract_shapes", _wrap_abstract_shapes, METH_VARARGS, "\n"
		"abstract_shapes(std::string structure, unsigned int level=5) -> std::string\n"
		"abstract_shapes(IntVector pt, unsigned int level=5) -> std::string\n"
		"abstract_shapes(varArrayShort pt, unsigned int level=5) -> std::string\n"
		"\n"
		"\n"
		"Convert a secondary structure in dot-bracket notation to its abstract shapes representation.  \n"
		"\n"
		"This function converts a secondary structure into its abstract shapes representation as presented by\n"
		":cite:t:`giegerich:2004` .  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as an overloaded function `abstract_shapes()` where the optional\n"
		"    second parameter `level` defaults to 5. See, e.g.   :py:func:`RNA.abstract_shapes()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    A secondary structure in dot-bracket notation  \n"
		"level : unsigned int\n"
		"    The abstraction level (integer in the range of 0 to 5)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The secondary structure in abstract shapes notation  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.abstract_shapes_pt()  \n"
		"\n"
		""},
	 { "ptable", (PyCFunction)(void(*)(void))_wrap_ptable, METH_VARARGS|METH_KEYWORDS, "\n"
		"ptable(std::string str, unsigned int options=) -> varArrayShort\n"
		"\n"
		"\n"
		"Create a pair table for a secondary structure string.  \n"
		"\n"
		"This function takes an input string of a secondary structure annotation in dot-bracket-notation or\n"
		"dot-bracket-ext-notation, and converts it into a pair table representation.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This functions is wrapped as overloaded function `ptable()` that takes an optional argument\n"
		"    `options` to specify which type of matching brackets should be considered during conversion. The\n"
		"    default set is round brackets, i.e. RNA.BRACKETS_RND. See, e.g.   :py:func:`RNA.ptable()` in\n"
		"    the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket-ext-notation  \n"
		"options : unsigned int\n"
		"    A bitmask to specify which brackets are recognized during conversion to pair table  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"short *  \n"
		"    A pointer to a new pair table of the provided secondary structure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.ptable(), RNA.db_from_ptable(), RNA.db_flatten_to(), RNA.pt_pk_remove()RNA.BRACKETS_RND,\n"
		"RNA.BRACKETS_ANG, RNA.BRACKETS_CLY, RNA.BRACKETS_SQR, RNA.BRACKETS_ALPHA, RNA.BRACKETS_DEFAULT,\n"
		"RNA.BRACKETS_ANY  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function also extracts crossing base pairs, i.e. pseudo-knots if more than a single matching\n"
		"bracket type is allowed through the bitmask `options`.  \n"
		"\n"
		""},
	 { "ptable_pk", (PyCFunction)(void(*)(void))_wrap_ptable_pk, METH_VARARGS|METH_KEYWORDS, "\n"
		"ptable_pk(std::string str) -> IntVector\n"
		"\n"
		"\n"
		"Create a pair table of a secondary structure (pseudo-knot version).  \n"
		"\n"
		"Returns a newly allocated table, such that table[i]=j if (i.j) pair or 0 if i is unpaired, table[0]\n"
		"contains the length of the structure.  \n"
		"\n"
		"In contrast to RNA.ptable() this function also recognizes the base pairs denoted by '[' and ']'\n"
		"brackets. Thus, this function behaves like  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure in (extended) dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"short *  \n"
		"    A pointer to the created pair_table  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.ptable_from_string()  \n"
		"\n"
		""},
	 { "pt_pk_remove", _wrap_pt_pk_remove, METH_VARARGS, "\n"
		"pt_pk_remove(IntVector pt, unsigned int options=0) -> IntVector\n"
		"pt_pk_remove(varArrayShort pt, unsigned int options=0) -> varArrayShort\n"
		"\n"
		"\n"
		"Remove pseudo-knots from a pair table.  \n"
		"\n"
		"This function removes pseudo-knots from an input structure by determining the minimum number of base\n"
		"pairs that need to be removed to make the structure pseudo-knot free.  \n"
		"\n"
		"To accomplish that, we use a dynamic programming algorithm similar to the Nussinov maxmimum matching\n"
		"approach.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ptable : const short *\n"
		"    Input structure that may include pseudo-knots  \n"
		"options : unsigned int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"short *  \n"
		"    The input structure devoid of pseudo-knots  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.db_pk_remove()  \n"
		"\n"
		""},
	 { "plist", (PyCFunction)(void(*)(void))_wrap_plist, METH_VARARGS|METH_KEYWORDS, "\n"
		"plist(std::string structure, float pr) -> ElemProbVector\n"
		"\n"
		"\n"
		"Create a RNA.ep() from a dot-bracket string.  \n"
		"\n"
		"The dot-bracket string is parsed and for each base pair an entry in the plist is created. The\n"
		"probability of each pair in the list is set by a function parameter.  \n"
		"\n"
		"The end of the plist is marked by sequence positions i as well as j equal to 0. This condition\n"
		"should be used to stop looping over its entries  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"struc : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"pr : float\n"
		"    The probability for each base pair used in the plist  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.ep() *  \n"
		"    The plist array  \n"
		"\n"
		""},
	 { "db_from_plist", (PyCFunction)(void(*)(void))_wrap_db_from_plist, METH_VARARGS|METH_KEYWORDS, "\n"
		"db_from_plist(ElemProbVector elem_probs, unsigned int length) -> std::string\n"
		"\n"
		"\n"
		"Convert a list of base pairs into dot-bracket notation.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pairs : RNA.ep() *\n"
		"    A RNA.ep() containing the pairs to be included in the dot-bracket string  \n"
		"n : unsigned int\n"
		"    The length of the structure (number of nucleotides)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The dot-bracket string containing the provided base pairs  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plist()  \n"
		"\n"
		""},
	 { "db_pk_remove", (PyCFunction)(void(*)(void))_wrap_db_pk_remove, METH_VARARGS|METH_KEYWORDS, "\n"
		"db_pk_remove(std::string structure, unsigned int options=) -> std::string\n"
		"\n"
		"\n"
		"Remove pseudo-knots from an input structure.  \n"
		"\n"
		"This function removes pseudo-knots from an input structure by determining the minimum number of base\n"
		"pairs that need to be removed to make the structure pseudo-knot free.  \n"
		"\n"
		"To accomplish that, we use a dynamic programming algorithm similar to the Nussinov maxmimum matching\n"
		"approach.  \n"
		"\n"
		"The input structure must be in a dot-bracket string like form where crossing base pairs are denoted\n"
		"by the use of additional types of matching brackets, e.g. `<>`, `{}`, ``[], `{}`. Furthermore,\n"
		"crossing pairs may be annotated by matching uppercase/lowercase letters from the alphabet `A-Z`. For\n"
		"the latter, the uppercase letter must be the 5' and the lowercase letter the 3' nucleotide of the\n"
		"base pair. The actual type of brackets to be recognized by this function must be specifed through\n"
		"the `options` parameter.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as an overloaded function `db_pk_remove()` where the optional second\n"
		"    parameter `options` defaults to RNA.BRACKETS_ANY. See, e.g.   :py:func:`RNA.db_pk_remove()` in\n"
		"    the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    Input structure in dot-bracket format that may include pseudo-knots  \n"
		"options : unsigned int\n"
		"    A bitmask to specify which types of brackets should be processed  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The input structure devoid of pseudo-knots in dot-bracket notation  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.pt_pk_remove(), RNA.db_flatten(), RNA.BRACKETS_RND, RNA.BRACKETS_ANG, RNA.BRACKETS_CLY,\n"
		"RNA.BRACKETS_SQR, RNA.BRACKETS_ALPHA, RNA.BRACKETS_DEFAULT, RNA.BRACKETS_ANY  \n"
		"\n"
		"Note\n"
		"----\n"
		"Brackets in the input structure string that are not covered by the `options` bitmask will be\n"
		"silently ignored!  \n"
		"\n"
		""},
	 { "db_to_tree_string", (PyCFunction)(void(*)(void))_wrap_db_to_tree_string, METH_VARARGS|METH_KEYWORDS, "\n"
		"db_to_tree_string(std::string structure, unsigned int type) -> std::string\n"
		"\n"
		"\n"
		"Convert a Dot-Bracket structure string into tree string representation.  \n"
		"\n"
		"This function allows one to convert a secondary structure in dot-bracket notation into one of the\n"
		"various tree representations for secondary structures. The resulting tree is then represented as a\n"
		"string of parenthesis and node symbols, similar to to the Newick format.  \n"
		"\n"
		"Currently we support conversion into the following formats, denoted by the value of parameter\n"
		"`type:`  \n"
		"\n"
		"*   RNA.STRUCTURE_TREE_HIT -   Homeomorphically Irreducible Tree (HIT) representation of a\n"
		"    secondary structure.    (See also    :cite:t:`fontana:1993b` )  \n"
		"*   RNA.STRUCTURE_TREE_SHAPIRO_SHORT -   (short) Coarse Grained representation of a secondary\n"
		"    structure    (same as    :cite:t:`shapiro:1988` , but with root node `R` and without `S` nodes\n"
		"    for the stems)  \n"
		"*   RNA.STRUCTURE_TREE_SHAPIRO -   (full) Coarse Grained representation of a secondary structure\n"
		"    (See also    :cite:t:`shapiro:1988` )  \n"
		"*   RNA.STRUCTURE_TREE_SHAPIRO_EXT -   (extended) Coarse Grained representation of a secondary\n"
		"    structure    (same as    :cite:t:`shapiro:1988` , but external nodes denoted as `E` )  \n"
		"*   RNA.STRUCTURE_TREE_SHAPIRO_WEIGHT -   (weighted) Coarse Grained representation of a secondary\n"
		"    structure    (same as RNA.STRUCTURE_TREE_SHAPIRO_EXT but with additional weights for number of\n"
		"    unpaired nucleotides in loop, and number of pairs in stems)  \n"
		"*   RNA.STRUCTURE_TREE_EXPANDED -   Expanded Tree representation of a secondary structure.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The null-terminated dot-bracket structure string  \n"
		"type : unsigned int\n"
		"    A switch to determine the type of tree string representation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A tree representation of the input `structure`  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"sec_structure_representations_tree  \n"
		"\n"
		""},
	 { "tree_string_unweight", (PyCFunction)(void(*)(void))_wrap_tree_string_unweight, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Remove weights from a linear string tree representation of a secondary structure.  \n"
		"\n"
		"This function strips the weights of a linear string tree representation such as `HIT`, or Coarse\n"
		"Grained Tree sensu    :cite:t:`shapiro:1988`  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    A linear string tree representation of a secondary structure with weights  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A linear string tree representation of a secondary structure without weights  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.db_to_tree_string()  \n"
		"\n"
		""},
	 { "tree_string_to_db", (PyCFunction)(void(*)(void))_wrap_tree_string_to_db, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Convert a linear tree string representation of a secondary structure back to Dot-Bracket notation.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"tree : const char *\n"
		"    A linear tree string representation of a secondary structure  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A dot-bracket notation of the secondary structure provided in `tree`  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"This function only accepts *Expanded* and *HIT* tree representations!  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.db_to_tree_string(), RNA.STRUCTURE_TREE_EXPANDED, RNA.STRUCTURE_TREE_HIT,\n"
		"sec_structure_representations_tree  \n"
		"\n"
		""},
	 { "make_loop_index", (PyCFunction)(void(*)(void))_wrap_make_loop_index, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "loopidx_from_ptable", _wrap_loopidx_from_ptable, METH_VARARGS, "\n"
		"loopidx_from_ptable(IntVector pt) -> IntVector\n"
		"loopidx_from_ptable(varArrayShort pt) -> varArrayInt\n"
		"\n"
		"\n"
		"Get a loop index representation of a structure.  \n"
		"\n"
		""},
	 { "hx_start_set", _wrap_hx_start_set, METH_VARARGS, NULL},
	 { "hx_start_get", _wrap_hx_start_get, METH_O, NULL},
	 { "hx_end_set", _wrap_hx_end_set, METH_VARARGS, NULL},
	 { "hx_end_get", _wrap_hx_end_get, METH_O, NULL},
	 { "hx_length_set", _wrap_hx_length_set, METH_VARARGS, NULL},
	 { "hx_length_get", _wrap_hx_length_get, METH_O, NULL},
	 { "hx_up5_set", _wrap_hx_up5_set, METH_VARARGS, NULL},
	 { "hx_up5_get", _wrap_hx_up5_get, METH_O, NULL},
	 { "hx_up3_set", _wrap_hx_up3_set, METH_VARARGS, NULL},
	 { "hx_up3_get", _wrap_hx_up3_get, METH_O, NULL},
	 { "new_hx", (PyCFunction)(void(*)(void))_wrap_new_hx, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "hx___str__", _wrap_hx___str__, METH_O, NULL},
	 { "delete_hx", _wrap_delete_hx, METH_O, NULL},
	 { "hx_swigregister", hx_swigregister, METH_O, NULL},
	 { "hx_swiginit", hx_swiginit, METH_VARARGS, NULL},
	 { "hx_from_ptable", _wrap_hx_from_ptable, METH_VARARGS, "\n"
		"hx_from_ptable(IntVector pt) -> HelixVector\n"
		"hx_from_ptable(varArrayShort pt) -> HelixVector\n"
		"\n"
		"\n"
		"Convert a pair table representation of a secondary structure into a helix list.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : short *\n"
		"    The secondary structure in pair table representation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.hx() *  \n"
		"    The secondary structure represented as a helix list  \n"
		"\n"
		""},
	 { "hx_merge", (PyCFunction)(void(*)(void))_wrap_hx_merge, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "bp_distance", _wrap_bp_distance, METH_VARARGS, "\n"
		"bp_distance(std::string str1, std::string str2, unsigned int options=) -> int\n"
		"bp_distance(IntVector pt1, IntVector pt2) -> int\n"
		"bp_distance(varArrayShort pt1, varArrayShort pt2) -> int\n"
		"\n"
		"\n"
		"Compute the \"base pair\" distance between two secondary structures s1 and s2.  \n"
		"\n"
		"This is a wrapper around **RNA.bp_distance_pt()**. The sequences should have the same length. dist\n"
		"= number of base pairs in one structure but not in the other same as edit distance with open-pair\n"
		"close-pair as move-set  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as an overloaded method **bp_distance()**. Note that the SWIG wrapper\n"
		"    takes two structure in dot-bracket notation and converts them into pair tables using\n"
		"    RNA.ptable_from_string(). The resulting pair tables are then internally passed to\n"
		"    RNA.bp_distance_pt(). To control which kind of matching brackets will be used during\n"
		"    conversion, the optional argument `options` can be used. See also the description of\n"
		"    RNA.ptable_from_string() for available options. (default: **RNA.BRACKETS_RND**). See, e.g.\n"
		"    :py:func:`RNA.bp_distance()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"str1 : const char *\n"
		"    First structure in dot-bracket notation  \n"
		"str2 : const char *\n"
		"    Second structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The base pair distance between str1 and str2  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.bp_distance_pt()  \n"
		"\n"
		""},
	 { "dist_mountain", (PyCFunction)(void(*)(void))_wrap_dist_mountain, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "score_TP_set", _wrap_score_TP_set, METH_VARARGS, NULL},
	 { "score_TP_get", _wrap_score_TP_get, METH_O, NULL},
	 { "score_TN_set", _wrap_score_TN_set, METH_VARARGS, NULL},
	 { "score_TN_get", _wrap_score_TN_get, METH_O, NULL},
	 { "score_FP_set", _wrap_score_FP_set, METH_VARARGS, NULL},
	 { "score_FP_get", _wrap_score_FP_get, METH_O, NULL},
	 { "score_FN_set", _wrap_score_FN_set, METH_VARARGS, NULL},
	 { "score_FN_get", _wrap_score_FN_get, METH_O, NULL},
	 { "score_TPR_set", _wrap_score_TPR_set, METH_VARARGS, NULL},
	 { "score_TPR_get", _wrap_score_TPR_get, METH_O, NULL},
	 { "score_PPV_set", _wrap_score_PPV_set, METH_VARARGS, NULL},
	 { "score_PPV_get", _wrap_score_PPV_get, METH_O, NULL},
	 { "score_FPR_set", _wrap_score_FPR_set, METH_VARARGS, NULL},
	 { "score_FPR_get", _wrap_score_FPR_get, METH_O, NULL},
	 { "score_FOR_set", _wrap_score_FOR_set, METH_VARARGS, NULL},
	 { "score_FOR_get", _wrap_score_FOR_get, METH_O, NULL},
	 { "score_TNR_set", _wrap_score_TNR_set, METH_VARARGS, NULL},
	 { "score_TNR_get", _wrap_score_TNR_get, METH_O, NULL},
	 { "score_FDR_set", _wrap_score_FDR_set, METH_VARARGS, NULL},
	 { "score_FDR_get", _wrap_score_FDR_get, METH_O, NULL},
	 { "score_FNR_set", _wrap_score_FNR_set, METH_VARARGS, NULL},
	 { "score_FNR_get", _wrap_score_FNR_get, METH_O, NULL},
	 { "score_NPV_set", _wrap_score_NPV_set, METH_VARARGS, NULL},
	 { "score_NPV_get", _wrap_score_NPV_get, METH_O, NULL},
	 { "score_F1_set", _wrap_score_F1_set, METH_VARARGS, NULL},
	 { "score_F1_get", _wrap_score_F1_get, METH_O, NULL},
	 { "score_MCC_set", _wrap_score_MCC_set, METH_VARARGS, NULL},
	 { "score_MCC_get", _wrap_score_MCC_get, METH_O, NULL},
	 { "new_score", (PyCFunction)(void(*)(void))_wrap_new_score, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "score___str__", _wrap_score___str__, METH_O, NULL},
	 { "delete_score", _wrap_delete_score, METH_O, NULL},
	 { "score_swigregister", score_swigregister, METH_O, NULL},
	 { "score_swiginit", score_swiginit, METH_VARARGS, NULL},
	 { "compare_structure", _wrap_compare_structure, METH_VARARGS, "\n"
		"compare_structure(std::string str1, std::string str2, int fuzzy=0, unsigned int options=) -> score\n"
		"compare_structure(IntVector pt1, IntVector pt2, int fuzzy=0) -> score\n"
		"compare_structure(varArrayShort pt1, varArrayShort pt2, int fuzzy=0) -> score\n"
		""},
	 { "gq_parse", (PyCFunction)(void(*)(void))_wrap_gq_parse, METH_VARARGS|METH_KEYWORDS, "gq_parse(std::string structure) -> unsigned int"},
	 { "db_pack", (PyCFunction)(void(*)(void))_wrap_db_pack, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Pack secondary secondary structure, 5:1 compression using base 3 encoding.  \n"
		"\n"
		"Returns a binary string encoding of the secondary structure using a 5:1 compression scheme. The\n"
		"string is NULL terminated and can therefore be used with standard string functions such as strcmp().\n"
		"Useful for programs that need to keep many structures in memory.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"struc : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The binary encoded structure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.db_unpack()  \n"
		"\n"
		""},
	 { "db_unpack", (PyCFunction)(void(*)(void))_wrap_db_unpack, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Unpack secondary structure previously packed with RNA.db_pack().  \n"
		"\n"
		"Translate a compressed binary string produced by RNA.db_pack() back into the familiar dot-bracket\n"
		"notation.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"packed : const char *\n"
		"    The binary encoded packed secondary structure  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The unpacked secondary structure in dot-bracket notation  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.db_pack()  \n"
		"\n"
		""},
	 { "db_to_element_string", (PyCFunction)(void(*)(void))_wrap_db_to_element_string, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Convert a secondary structure in dot-bracket notation to a nucleotide annotation of loop contexts.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A string annotating each nucleotide according to it's structural context  \n"
		"\n"
		""},
	 { "parse_gquad", (PyCFunction)(void(*)(void))_wrap_parse_gquad, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Parse a G-Quadruplex from a dot-bracket structure string.  \n"
		"\n"
		"Given a dot-bracket structure (possibly) containing gquads encoded by '+' signs, find first gquad,\n"
		"return end position or 0 if none found Upon return L and l[] contain the number of stacked layers,\n"
		"as well as the lengths of the linker regions. To parse a string with many gquads, call parse_gquad\n"
		"repeatedly e.g. end1 = parse_gquad(struc, &L, l); ... ; end2 = parse_gquad(struc+end1, &L, l);\n"
		"end2+=end1; ... ; end3 = parse_gquad(struc+end2, &L, l); end3+=end2; ... ;  \n"
		"\n"
		""},
	 { "get_plist_gquad_from_db", (PyCFunction)(void(*)(void))_wrap_get_plist_gquad_from_db, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "aln_consensus_sequence", (PyCFunction)(void(*)(void))_wrap_aln_consensus_sequence, METH_VARARGS|METH_KEYWORDS, "\n"
		"aln_consensus_sequence(StringVector alignment, md md_p=None) -> std::string\n"
		"\n"
		"\n"
		"Compute the consensus sequence for a given multiple sequence alignment.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `aln_consensus_sequence()` where the last\n"
		"    parameter may be omitted, indicating `md` = `NULL`. See e.g.\n"
		"    :py:func:`RNA.aln_consensus_sequence()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alignment : const char **\n"
		"    The input sequence alignment (last entry must be *NULL* terminated)  \n"
		"md_p : const RNA.md() *\n"
		"    Model details that specify known nucleotides (Maybe *NULL*)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The consensus sequence of the alignment, i.e. the most frequent nucleotide for each alignment\n"
		"    column  \n"
		"\n"
		""},
	 { "aln_consensus_mis", (PyCFunction)(void(*)(void))_wrap_aln_consensus_mis, METH_VARARGS|METH_KEYWORDS, "\n"
		"aln_consensus_mis(StringVector alignment, md md_p=None) -> std::string\n"
		"\n"
		"\n"
		"Compute the Most Informative Sequence (MIS) for a given multiple sequence alignment.  \n"
		"\n"
		"The most informative sequence (MIS)    :cite:p:`freyhult:2005`  displays for each alignment column\n"
		"the nucleotides with frequency greater than the background frequency, projected into IUPAC notation.\n"
		"Columns where gaps are over-represented are in lower case.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `aln_consensus_mis()` where the last parameter\n"
		"    may be omitted, indicating `md` = `NULL`. See e.g.   :py:func:`RNA.aln_consensus_mis()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alignment : const char **\n"
		"    The input sequence alignment (last entry must be *NULL* terminated)  \n"
		"md_p : const RNA.md() *\n"
		"    Model details that specify known nucleotides (Maybe *NULL*)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The most informative sequence for the alignment  \n"
		"\n"
		""},
	 { "my_aln_consensus_sequence2", (PyCFunction)(void(*)(void))_wrap_my_aln_consensus_sequence2, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "consens_mis", (PyCFunction)(void(*)(void))_wrap_consens_mis, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "aln_mpi", (PyCFunction)(void(*)(void))_wrap_aln_mpi, METH_VARARGS|METH_KEYWORDS, "\n"
		"aln_mpi(StringVector alignment) -> int\n"
		"\n"
		"\n"
		"Get the mean pairwise identity in steps from ?to?(ident).  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `aln_mpi()`. See e.g.   :py:func:`RNA.aln_mpi()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alignment : const char **\n"
		"    Aligned sequences  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The mean pairwise identity  \n"
		"\n"
		""},
	 { "aln_pscore", (PyCFunction)(void(*)(void))_wrap_aln_pscore, METH_VARARGS|METH_KEYWORDS, "\n"
		"aln_pscore(StringVector alignment, md md=None) -> IntIntVector\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `aln_pscore()` where the last parameter may be\n"
		"    omitted, indicating `md` = `NULL`. See e.g.   :py:func:`RNA.aln_pscore()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		""},
	 { "aln_conservation_struct", (PyCFunction)(void(*)(void))_wrap_aln_conservation_struct, METH_VARARGS|METH_KEYWORDS, "\n"
		"aln_conservation_struct(StringVector alignment, std::string structure, md md=None) -> DoubleVector\n"
		"\n"
		"\n"
		"Compute base pair conservation of a consensus structure.  \n"
		"\n"
		"This function computes the base pair conservation (fraction of canonical base pairs) of a consensus\n"
		"structure given a multiple sequence alignment. The base pair types that are considered canonical may\n"
		"be specified using the RNA.md().pair array. Passing *NULL* as parameter `md` results in default\n"
		"pairing rules, i.e. canonical Watson-Crick and GU Wobble pairs.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `aln_conservation_struct()` where the last\n"
		"    parameter `md` may be omitted, indicating `md` = `NULL`. See, e.g.\n"
		"    :py:func:`RNA.aln_conservation_struct()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alignment : const char **\n"
		"    The input sequence alignment (last entry must be *NULL* terminated)  \n"
		"structure : const char *\n"
		"    The consensus structure in dot-bracket notation  \n"
		"md : const RNA.md() *\n"
		"    Model details that specify compatible base pairs (Maybe *NULL*)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float *  \n"
		"    A 1-based vector of base pair conservations  \n"
		"\n"
		""},
	 { "aln_conservation_col", (PyCFunction)(void(*)(void))_wrap_aln_conservation_col, METH_VARARGS|METH_KEYWORDS, "\n"
		"aln_conservation_col(StringVector alignment, md md=None, unsigned int options=) -> DoubleVector\n"
		"\n"
		"\n"
		"Compute nucleotide conservation in an alignment.  \n"
		"\n"
		"This function computes the conservation of nucleotides in alignment columns. The simples measure is\n"
		"Shannon Entropy and can be selected by passing the RNA.MEASURE_SHANNON_ENTROPY flag in the\n"
		"`options` parameter.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `aln_conservation_col()` where the last two\n"
		"    parameters may be omitted, indicating `md` = `NULL`, and `options` =\n"
		"    RNA.MEASURE_SHANNON_ENTROPY, respectively. See e.g.   :py:func:`RNA.aln_conservation_col()` in\n"
		"    the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"alignment : const char **\n"
		"    The input sequence alignment (last entry must be *NULL* terminated)  \n"
		"md :\n"
		"    Model details that specify known nucleotides (Maybe *NULL*)  \n"
		"options : unsigned int\n"
		"    A flag indicating which measure of conservation should be applied  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float *  \n"
		"    A 1-based vector of column conservations  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.MEASURE_SHANNON_ENTROPY  \n"
		"\n"
		"Note\n"
		"----\n"
		"Currently, only RNA.MEASURE_SHANNON_ENTROPY is supported as conservation measure.  \n"
		"\n"
		""},
	 { "move_standard", (PyCFunction)(void(*)(void))_wrap_move_standard, METH_VARARGS|METH_KEYWORDS, "move_standard(char * seq, char * struc, enum MOVE_TYPE type, int verbosity_level, int shifts, int noLP) -> char *"},
	 { "struct_en_energy_set", _wrap_struct_en_energy_set, METH_VARARGS, NULL},
	 { "struct_en_energy_get", _wrap_struct_en_energy_get, METH_O, NULL},
	 { "struct_en_structure_set", _wrap_struct_en_structure_set, METH_VARARGS, NULL},
	 { "struct_en_structure_get", _wrap_struct_en_structure_get, METH_O, NULL},
	 { "new_struct_en", _wrap_new_struct_en, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Data structure for energy_of_move().  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"energy : int  \n"
		"\n"
		"structure : short *  \n"
		"\n"
		""},
	 { "delete_struct_en", _wrap_delete_struct_en, METH_O, NULL},
	 { "struct_en_swigregister", struct_en_swigregister, METH_O, NULL},
	 { "struct_en_swiginit", struct_en_swiginit, METH_VARARGS, NULL},
	 { "filename_sanitize", _wrap_filename_sanitize, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Sanitize a file name.  \n"
		"\n"
		"Returns a new file name where all invalid characters are substituted by a replacement character. If\n"
		"no replacement character is supplied, invalid characters are simply removed from the filename. File\n"
		"names may also never exceed a length of 255 characters. Longer file names will undergo a 'smart'\n"
		"truncation process, where the filenames' suffix, i.e. everything after the last dot '.', is\n"
		"attempted to be kept intact. Hence, only the filename part before the suffix is reduced in such a\n"
		"way that the total filename complies to the length restriction of 255 characters. If no suffix is\n"
		"present or the suffix itself already exceeds the maximum length, the filename is simply truncated\n"
		"from the back of the string.  \n"
		"\n"
		"For now we consider the following characters invalid:  \n"
		"\n"
		"*   backslash '\\'  \n"
		"*   slash '/'  \n"
		"*   question mark '?'  \n"
		"*   percent sign ''  \n"
		"*   asterisk '*'  \n"
		"*   colon ':'  \n"
		"*   pipe symbol '|'  \n"
		"*   double quote '\"'  \n"
		"*   triangular brackets '<' and '>'  \n"
		"\n"
		"Furthermore, the (resulting) file name must not be a reserved file name, such as:  \n"
		"\n"
		"*   '.'  \n"
		"*   '..'  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"name : const char *\n"
		"    The input file name  \n"
		"replacement : const char *\n"
		"    The replacement character, or NULL  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The sanitized file name, or NULL  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function allocates a new block of memory for the sanitized string. It also may return (a) NULL\n"
		"if the input is pointing to NULL, or (b) an empty string if the input only consists of invalid\n"
		"characters which are simply removed!  \n"
		"\n"
		""},
	 { "log_cb_add_pycallback", (PyCFunction)(void(*)(void))_wrap_log_cb_add_pycallback, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "log_cb_add", (PyCFunction)(void(*)(void))_wrap_log_cb_add, METH_VARARGS|METH_KEYWORDS, "log_cb_add(PyObject * callback, PyObject * data=Py_None, PyObject * data_release=Py_None, vrna_log_levels_e level=VRNA_LOG_LEVEL_WARNING) -> unsigned int"},
	 { "log_level", _wrap_log_level, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Get the current default log level.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.log_levels  \n"
		"    The current default log level  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.log_level_set(), RNA.log_levels  \n"
		"\n"
		""},
	 { "log_level_set", (PyCFunction)(void(*)(void))_wrap_log_level_set, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Set the default log level.  \n"
		"\n"
		"Set the log level for the default log output system. Any user-defined log callback mechanism will\n"
		"not be affected...  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"level : RNA.log_levels\n"
		"    The new log level for the default logging system  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The (updated) log level of the default logging system  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.log_level(), RNA.log_levels, RNA.log_cb_add(), RNA.log_reset()  \n"
		"\n"
		""},
	 { "log_options", _wrap_log_options, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Get the current log options of the default logging system.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int  \n"
		"    The current options for the default logging system  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.log_options_set(), RNA.LOG_OPTION_QUIET, RNA.LOG_OPTION_TRACE_TIMERNA.LOG_OPTION_TRACE_CALL,\n"
		"RNA.LOG_OPTION_DEFAULT  \n"
		"\n"
		""},
	 { "log_options_set", (PyCFunction)(void(*)(void))_wrap_log_options_set, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Set the log options for the default logging system.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"options : unsigned int\n"
		"    The new options for the default logging system  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.log_options(), RNA.LOG_OPTION_QUIET, RNA.LOG_OPTION_TRACE_TIMERNA.LOG_OPTION_TRACE_CALL,\n"
		"RNA.LOG_OPTION_DEFAULT  \n"
		"\n"
		""},
	 { "log_fp", _wrap_log_fp, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Get the output file pointer for the default logging system.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"FILE *  \n"
		"    The file pointer where the default logging system will print log messages to  \n"
		"\n"
		""},
	 { "log_fp_set", (PyCFunction)(void(*)(void))_wrap_log_fp_set, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Set the output file pointer for the default logging system.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fp : FILE *\n"
		"    The file pointer where the default logging system should print log messages to  \n"
		"\n"
		""},
	 { "log_cb_num", _wrap_log_cb_num, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Get the current number of log message callbacks.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"size()  \n"
		"    The current number of log message callbacks stored in the logging system  \n"
		"\n"
		""},
	 { "log_reset", _wrap_log_reset, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Reset the logging system.  \n"
		"\n"
		"This resets the logging system and restores default settings  \n"
		"\n"
		""},
	 { "get_xy_coordinates", (PyCFunction)(void(*)(void))_wrap_get_xy_coordinates, METH_VARARGS|METH_KEYWORDS, "\n"
		"get_xy_coordinates(char const * structure) -> COORDINATE\n"
		"\n"
		"\n"
		"Compute nucleotide coordinates for secondary structure plot.  \n"
		"\n"
		"This function takes a secondary structure and computes X-Y coordinates for each nucleotide that then\n"
		"can be used to create a structure plot. The parameter `plot_type` is used to select the underlying\n"
		"layout algorithm. Currently, the following selections are provided:  \n"
		"\n"
		"*   RNA.PLOT_TYPE_SIMPLE  \n"
		"*   RNA.PLOT_TYPE_NAVIEW  \n"
		"*   RNA.PLOT_TYPE_CIRCULAR  \n"
		"*   RNA.PLOT_TYPE_TURTLE  \n"
		"*   RNA.PLOT_TYPE_PUZZLER  \n"
		"\n"
		"Passing an unsupported selection leads to the default algorithm RNA.PLOT_TYPE_NAVIEW  \n"
		"\n"
		"Here is a simple example how to use this function, assuming variable `structure` contains a valid\n"
		"dot-bracket string:  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"x : float **\n"
		"    The address of a pointer of X coordinates (pointer will point to memory, or NULL on failure)  \n"
		"y : float **\n"
		"    The address of a pointer of Y coordinates (pointer will point to memory, or NULL on failure)  \n"
		"plot_type : int\n"
		"    The layout algorithm to be used  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The length of the structure on success, 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plot_coords_pt(), RNA.plot_coords_simple(), RNA.plot_coords_naview()\n"
		"RNA.plot_coords_circular(), RNA.plot_coords_turtle(), RNA.plot_coords_puzzler()  \n"
		"\n"
		"Note\n"
		"----\n"
		"On success, this function allocates memory for X and Y coordinates and assigns the pointers at\n"
		"addressess `x` and `y` to the corresponding memory locations. It's the users responsibility to\n"
		"cleanup this memory after usage!  \n"
		"\n"
		""},
	 { "simple_circplot_coordinates", (PyCFunction)(void(*)(void))_wrap_simple_circplot_coordinates, METH_VARARGS|METH_KEYWORDS, "simple_circplot_coordinates(std::string arg1) -> CoordinateVector"},
	 { "naview_xy_coordinates", (PyCFunction)(void(*)(void))_wrap_naview_xy_coordinates, METH_VARARGS|METH_KEYWORDS, "naview_xy_coordinates(std::string arg1) -> CoordinateVector"},
	 { "new_plot_layout", (PyCFunction)(void(*)(void))_wrap_new_plot_layout, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_plot_layout", _wrap_delete_plot_layout, METH_O, NULL},
	 { "plot_layout_swigregister", plot_layout_swigregister, METH_O, NULL},
	 { "plot_layout_swiginit", plot_layout_swiginit, METH_VARARGS, NULL},
	 { "plot_options_puzzler_checkAncestorIntersections_set", _wrap_plot_options_puzzler_checkAncestorIntersections_set, METH_VARARGS, NULL},
	 { "plot_options_puzzler_checkAncestorIntersections_get", _wrap_plot_options_puzzler_checkAncestorIntersections_get, METH_O, NULL},
	 { "plot_options_puzzler_checkSiblingIntersections_set", _wrap_plot_options_puzzler_checkSiblingIntersections_set, METH_VARARGS, NULL},
	 { "plot_options_puzzler_checkSiblingIntersections_get", _wrap_plot_options_puzzler_checkSiblingIntersections_get, METH_O, NULL},
	 { "plot_options_puzzler_checkExteriorIntersections_set", _wrap_plot_options_puzzler_checkExteriorIntersections_set, METH_VARARGS, NULL},
	 { "plot_options_puzzler_checkExteriorIntersections_get", _wrap_plot_options_puzzler_checkExteriorIntersections_get, METH_O, NULL},
	 { "plot_options_puzzler_allowFlipping_set", _wrap_plot_options_puzzler_allowFlipping_set, METH_VARARGS, NULL},
	 { "plot_options_puzzler_allowFlipping_get", _wrap_plot_options_puzzler_allowFlipping_get, METH_O, NULL},
	 { "plot_options_puzzler_optimize_set", _wrap_plot_options_puzzler_optimize_set, METH_VARARGS, NULL},
	 { "plot_options_puzzler_optimize_get", _wrap_plot_options_puzzler_optimize_get, METH_O, NULL},
	 { "plot_options_puzzler_plot_options_puzzler", _wrap_plot_options_puzzler_plot_options_puzzler, METH_O, "\n"
		"\n"
		"\n"
		"Options data structure for RNApuzzler algorithm implementation.  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"drawArcs : short  \n"
		"\n"
		"paired : double  \n"
		"\n"
		"unpaired : double  \n"
		"\n"
		"checkAncestorIntersections : short  \n"
		"\n"
		"checkSiblingIntersections : short  \n"
		"\n"
		"checkExteriorIntersections : short  \n"
		"\n"
		"allowFlipping : short  \n"
		"\n"
		"optimize : short  \n"
		"\n"
		"maximumNumberOfConfigChangesAllowed : int  \n"
		"\n"
		"config : char *  \n"
		"\n"
		"filename : const char *  \n"
		"\n"
		"numberOfChangesAppliedToConfig : int  \n"
		"\n"
		"psNumber : int  \n"
		"\n"
		""},
	 { "delete_plot_options_puzzler", _wrap_delete_plot_options_puzzler, METH_O, NULL},
	 { "plot_options_puzzler_swigregister", plot_options_puzzler_swigregister, METH_O, NULL},
	 { "plot_layout_simple", (PyCFunction)(void(*)(void))_wrap_plot_layout_simple, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Create a layout (coordinates, etc.) for a *simple* secondary structure plot.  \n"
		"\n"
		"This function basically is a wrapper to RNA.plot_layout() that passes the\n"
		"`plot_type`RNA.PLOT_TYPE_SIMPLE.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.plot_layout() *  \n"
		"    The layout data structure for the provided secondary structure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plot_layout_free(), RNA.plot_layout(), RNA.plot_layout_naview(), RNA.plot_layout_circular(),\n"
		"RNA.plot_layout_turtle(), RNA.plot_layout_puzzler(), RNA.plot_coords_simple(),\n"
		"RNA.file_PS_rnaplot_layout()  \n"
		"\n"
		"Note\n"
		"----\n"
		"If only X-Y coordinates of the corresponding structure layout are required, consider using\n"
		"RNA.plot_coords_simple() instead!  \n"
		"\n"
		""},
	 { "plot_layout_naview", (PyCFunction)(void(*)(void))_wrap_plot_layout_naview, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "plot_layout_circular", (PyCFunction)(void(*)(void))_wrap_plot_layout_circular, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Create a layout (coordinates, etc.) for a *circular* secondary structure plot.  \n"
		"\n"
		"This function basically is a wrapper to RNA.plot_layout() that passes the\n"
		"`plot_type`RNA.PLOT_TYPE_CIRCULAR.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.plot_layout() *  \n"
		"    The layout data structure for the provided secondary structure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plot_layout_free(), RNA.plot_layout(), RNA.plot_layout_naview(), RNA.plot_layout_simple(),\n"
		"RNA.plot_layout_turtle(), RNA.plot_layout_puzzler(), RNA.plot_coords_circular(),\n"
		"RNA.file_PS_rnaplot_layout()  \n"
		"\n"
		"Note\n"
		"----\n"
		"If only X-Y coordinates of the corresponding structure layout are required, consider using\n"
		"RNA.plot_coords_circular() instead!  \n"
		"\n"
		""},
	 { "plot_layout_turtle", (PyCFunction)(void(*)(void))_wrap_plot_layout_turtle, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Create a layout (coordinates, etc.) for a secondary structure plot using the *Turtle Algorithm*\n"
		":cite:p:`wiegreffe:2018` .  \n"
		"\n"
		"This function basically is a wrapper to RNA.plot_layout() that passes the\n"
		"`plot_type`RNA.PLOT_TYPE_TURTLE.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.plot_layout() *  \n"
		"    The layout data structure for the provided secondary structure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plot_layout_free(), RNA.plot_layout(), RNA.plot_layout_simple(), RNA.plot_layout_circular(),\n"
		"RNA.plot_layout_naview(), RNA.plot_layout_puzzler(), RNA.plot_coords_turtle(),\n"
		"RNA.file_PS_rnaplot_layout()  \n"
		"\n"
		"Note\n"
		"----\n"
		"If only X-Y coordinates of the corresponding structure layout are required, consider using\n"
		"RNA.plot_coords_turtle() instead!  \n"
		"\n"
		""},
	 { "plot_layout_puzzler", (PyCFunction)(void(*)(void))_wrap_plot_layout_puzzler, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Create a layout (coordinates, etc.) for a secondary structure plot using the *RNApuzzler Algorithm*\n"
		":cite:p:`wiegreffe:2018` .  \n"
		"\n"
		"This function basically is a wrapper to RNA.plot_layout() that passes the\n"
		"`plot_type`RNA.PLOT_TYPE_PUZZLER.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.plot_layout() *  \n"
		"    The layout data structure for the provided secondary structure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plot_layout_free(), RNA.plot_layout(), RNA.plot_layout_simple(), RNA.plot_layout_circular(),\n"
		"RNA.plot_layout_naview(), RNA.plot_layout_turtle(), RNA.plot_coords_puzzler(),\n"
		"RNA.file_PS_rnaplot_layout()  \n"
		"\n"
		"Note\n"
		"----\n"
		"If only X-Y coordinates of the corresponding structure layout are required, consider using\n"
		"RNA.plot_coords_puzzler() instead!  \n"
		"\n"
		""},
	 { "COORDINATE_get", (PyCFunction)(void(*)(void))_wrap_COORDINATE_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "COORDINATE_X_set", _wrap_COORDINATE_X_set, METH_VARARGS, NULL},
	 { "COORDINATE_X_get", _wrap_COORDINATE_X_get, METH_O, NULL},
	 { "COORDINATE_Y_set", _wrap_COORDINATE_Y_set, METH_VARARGS, NULL},
	 { "COORDINATE_Y_get", _wrap_COORDINATE_Y_get, METH_O, NULL},
	 { "new_COORDINATE", _wrap_new_COORDINATE, METH_NOARGS, "\n"
		"\n"
		"\n"
		"this is a workarround for the SWIG Perl Wrapper RNA plot function that returns an array of type\n"
		"COORDINATE  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"X : float  \n"
		"\n"
		"Y : float  \n"
		"\n"
		""},
	 { "delete_COORDINATE", _wrap_delete_COORDINATE, METH_O, NULL},
	 { "COORDINATE_swigregister", COORDINATE_swigregister, METH_O, NULL},
	 { "COORDINATE_swiginit", COORDINATE_swiginit, METH_VARARGS, NULL},
	 { "simple_xy_coordinates", _wrap_simple_xy_coordinates, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate nucleotide coordinates for secondary structure plot the *Simple way*.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Consider switching to RNA.plot_coords_simple_pt() instead!  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"make_pair_table(), rna_plot_type, simple_circplot_coordinates(), naview_xy_coordinates(),\n"
		"RNA.file_PS_rnaplot_a(), RNA.file_PS_rnaplot, svg_rna_plot()  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pair_table : short *\n"
		"    The pair table of the secondary structure  \n"
		"X : float *\n"
		"    a pointer to an array with enough allocated space to hold the x coordinates  \n"
		"Y : float *\n"
		"    a pointer to an array with enough allocated space to hold the y coordinates  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    length of sequence on success, 0 otherwise  \n"
		"\n"
		""},
	 { "my_PS_rna_plot_snoop_a", (PyCFunction)(void(*)(void))_wrap_my_PS_rna_plot_snoop_a, METH_VARARGS|METH_KEYWORDS, "my_PS_rna_plot_snoop_a(std::string sequence, std::string structure, std::string filename, IntVector relative_access, StringVector seqs) -> int"},
	 { "file_PS_rnaplot", _wrap_file_PS_rnaplot, METH_VARARGS, NULL},
	 { "file_PS_rnaplot_a", _wrap_file_PS_rnaplot_a, METH_VARARGS, NULL},
	 { "plot_data_pre_set", _wrap_plot_data_pre_set, METH_VARARGS, NULL},
	 { "plot_data_pre_get", _wrap_plot_data_pre_get, METH_O, NULL},
	 { "plot_data_post_set", _wrap_plot_data_post_set, METH_VARARGS, NULL},
	 { "plot_data_post_get", _wrap_plot_data_post_get, METH_O, NULL},
	 { "plot_data_md_set", _wrap_plot_data_md_set, METH_VARARGS, NULL},
	 { "plot_data_md_get", _wrap_plot_data_md_get, METH_O, NULL},
	 { "plot_data_options_set", _wrap_plot_data_options_set, METH_VARARGS, NULL},
	 { "plot_data_options_get", _wrap_plot_data_options_get, METH_O, NULL},
	 { "new_plot_data", (PyCFunction)(void(*)(void))_wrap_new_plot_data, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_plot_data", _wrap_delete_plot_data, METH_O, NULL},
	 { "plot_data_swigregister", plot_data_swigregister, METH_O, NULL},
	 { "plot_data_swiginit", plot_data_swiginit, METH_VARARGS, NULL},
	 { "plot_structure", (PyCFunction)(void(*)(void))_wrap_plot_structure, METH_VARARGS|METH_KEYWORDS, "plot_structure(std::string filename, std::string sequence, std::string structure, unsigned int file_format=, plot_layout layout=None, plot_data data=None) -> int"},
	 { "plot_structure_eps", (PyCFunction)(void(*)(void))_wrap_plot_structure_eps, METH_VARARGS|METH_KEYWORDS, "plot_structure_eps(std::string filename, std::string sequence, std::string structure, plot_layout layout=None, plot_data data=None) -> int"},
	 { "plot_structure_svg", (PyCFunction)(void(*)(void))_wrap_plot_structure_svg, METH_VARARGS|METH_KEYWORDS, "plot_structure_svg(std::string filename, std::string sequence, std::string structure, plot_layout layout=None, plot_data data=None) -> int"},
	 { "plot_structure_gml", (PyCFunction)(void(*)(void))_wrap_plot_structure_gml, METH_VARARGS|METH_KEYWORDS, "plot_structure_gml(std::string filename, std::string sequence, std::string structure, plot_layout layout=None, plot_data data=None, char option='x') -> int"},
	 { "plot_structure_ssv", (PyCFunction)(void(*)(void))_wrap_plot_structure_ssv, METH_VARARGS|METH_KEYWORDS, "plot_structure_ssv(std::string filename, std::string sequence, std::string structure, plot_layout layout=None, plot_data data=None) -> int"},
	 { "plot_structure_xrna", (PyCFunction)(void(*)(void))_wrap_plot_structure_xrna, METH_VARARGS|METH_KEYWORDS, "plot_structure_xrna(std::string filename, std::string sequence, std::string structure, plot_layout layout=None, plot_data data=None) -> int"},
	 { "gmlRNA", (PyCFunction)(void(*)(void))_wrap_gmlRNA, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a secondary structure graph in Graph Meta Language (gml) and write it to a file.  \n"
		"\n"
		"If 'option' is an uppercase letter the RNA sequence is used to label nodes, if 'option' equals *'X'*\n"
		"or *'x'* the resulting file will coordinates for an initial layout of the graph.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : char *\n"
		"    The RNA sequence  \n"
		"structure : char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"ssfile : char *\n"
		"    The filename of the gml output  \n"
		"option : char\n"
		"    The option flag  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on success, 0 otherwise  \n"
		"\n"
		""},
	 { "ssv_rna_plot", (PyCFunction)(void(*)(void))_wrap_ssv_rna_plot, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a secondary structure graph in SStructView format.  \n"
		"\n"
		"Write coord file for SStructView  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : char *\n"
		"    The RNA sequence  \n"
		"structure : char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"ssfile : char *\n"
		"    The filename of the ssv output  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on success, 0 otherwise  \n"
		"\n"
		""},
	 { "svg_rna_plot", (PyCFunction)(void(*)(void))_wrap_svg_rna_plot, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a secondary structure plot in SVG format and write it to a file.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : char *\n"
		"    The RNA sequence  \n"
		"structure : char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"ssfile : char *\n"
		"    The filename of the svg output  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on success, 0 otherwise  \n"
		"\n"
		""},
	 { "xrna_plot", (PyCFunction)(void(*)(void))_wrap_xrna_plot, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a secondary structure plot for further editing in XRNA.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : char *\n"
		"    The RNA sequence  \n"
		"structure : char *\n"
		"    The secondary structure in dot-bracket notation  \n"
		"ssfile : char *\n"
		"    The filename of the xrna output  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on success, 0 otherwise  \n"
		"\n"
		""},
	 { "PS_rna_plot", (PyCFunction)(void(*)(void))_wrap_PS_rna_plot, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a secondary structure graph in PostScript and write it to 'filename'.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.file_PS_rnaplot() instead!  \n"
		"\n"
		""},
	 { "PS_rna_plot_a", (PyCFunction)(void(*)(void))_wrap_PS_rna_plot_a, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a secondary structure graph in PostScript including additional annotation macros and write\n"
		"it to 'filename'.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.file_PS_rnaplot_a() instead!  \n"
		"\n"
		""},
	 { "PS_rna_plot_a_gquad", (PyCFunction)(void(*)(void))_wrap_PS_rna_plot_a_gquad, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a secondary structure graph in PostScript including additional annotation macros and write\n"
		"it to 'filename' (detect and draw g-quadruplexes).  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.file_PS_rnaplot_a() instead!  \n"
		"\n"
		""},
	 { "file_PS_aln", (PyCFunction)(void(*)(void))_wrap_file_PS_aln, METH_VARARGS|METH_KEYWORDS, "\n"
		"file_PS_aln(std::string filename, StringVector alignment, StringVector identifiers, std::string structure, unsigned int start=0, unsigned int end=0, int offset=0, unsigned int columns=60) -> int\n"
		"\n"
		"\n"
		"Create an annotated PostScript alignment plot.  \n"
		"\n"
		"Similar to RNA.file_PS_aln() but allows the user to print a particular slice of the alignment by\n"
		"specifying a `start` and `end` position. The additional `offset` parameter allows for adjusting the\n"
		"alignment position ruler value.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `file_PS_aln()` where the last four parameter\n"
		"    may be omitted, indicating `start` = *0*, `end` = *0*, `offset` = *0*, and `columns` = *60*.\n"
		"    See, e.g.   :py:func:`RNA.file_PS_aln()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : const char *\n"
		"    The output file name  \n"
		"seqs : const char **\n"
		"    The aligned sequences  \n"
		"names : const char **\n"
		"    The names of the sequences  \n"
		"structure : const char *\n"
		"    The consensus structure in dot-bracket notation  \n"
		"start : unsigned int\n"
		"    The start of the alignment slice (a value of 0 indicates the first position of the alignment,\n"
		"    i.e. no slicing at 5' side)  \n"
		"end : unsigned int\n"
		"    The end of the alignment slice (a value of 0 indicates the last position of the alignment, i.e.\n"
		"    no slicing at 3' side)  \n"
		"offset : int\n"
		"    The alignment coordinate offset for the position ruler.  \n"
		"columns : unsigned int\n"
		"    The number of columns before the alignment is wrapped as a new block (a value of 0 indicates no\n"
		"    wrapping)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.file_PS_aln_slice()  \n"
		"\n"
		""},
	 { "plot_dp_EPS", (PyCFunction)(void(*)(void))_wrap_plot_dp_EPS, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce an encapsulate PostScript (EPS) dot-plot from one or two lists of base pair probabilities.  \n"
		"\n"
		"This function reads two RNA.ep() lists `upper` and `lower` (e.g. base pair probabilities and a\n"
		"secondary structure) and produces an EPS \"dot plot\" with filename `'filename'` where data from\n"
		"`upper` is placed in the upper-triangular and data from `lower` is placed in the lower triangular\n"
		"part of the matrix.  \n"
		" For default output, provide the flag RNA.PLOT_PROBABILITIES_DEFAULT as `options` parameter.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `plot_dp_EPS()` where the last three\n"
		"    parameters may be omitted. The default values for these parameters are `lower` = NULL, `auxdata`\n"
		"    = NULL, `options` = RNA.PLOT_PROBABILITIES_DEFAULT. See, e.g.   :py:func:`RNA.plot_dp_EPS()` in\n"
		"    the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : const char *\n"
		"    A filename for the EPS output  \n"
		"sequence : const char *\n"
		"    The RNA sequence  \n"
		"upper : RNA.ep() *\n"
		"    The base pair probabilities for the upper triangular part  \n"
		"lower : RNA.ep() *\n"
		"    The base pair probabilities for the lower triangular part  \n"
		"options : unsigned int\n"
		"    Options indicating which of the input data should be included in the dot-plot  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 if EPS file was successfully written, 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.plist(), RNA.fold_compound.plist_from_probs(), RNA.PLOT_PROBABILITIES_DEFAULT  \n"
		"\n"
		""},
	 { "PS_color_dot_plot", (PyCFunction)(void(*)(void))_wrap_PS_color_dot_plot, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "PS_color_dot_plot_turn", (PyCFunction)(void(*)(void))_wrap_PS_color_dot_plot_turn, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "PS_dot_plot_turn", (PyCFunction)(void(*)(void))_wrap_PS_dot_plot_turn, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "PS_dot_plot_list", (PyCFunction)(void(*)(void))_wrap_PS_dot_plot_list, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce a postscript dot-plot from two pair lists.  \n"
		"\n"
		"This function reads two plist structures (e.g. base pair probabilities and a secondary structure) as\n"
		"produced by assign_plist_from_pr() and assign_plist_from_db() and produces a postscript \"dot plot\"\n"
		"that is written to 'filename'.  \n"
		"Using base pair probabilities in the first and mfe structure in the second plist, the resulting\n"
		"\"dot plot\" represents each base pairing probability by a square of corresponding area in a upper\n"
		"triangle matrix. The lower part of the matrix contains the minimum free energy structure.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seq : char *\n"
		"    The RNA sequence  \n"
		"filename : char *\n"
		"    A filename for the postscript output  \n"
		"pl : RNA.ep() *\n"
		"    The base pair probability pairlist  \n"
		"mf : RNA.ep() *\n"
		"    The mfe secondary structure pairlist  \n"
		"comment : char *\n"
		"    A comment  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 if postscript was successfully written, 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"assign_plist_from_pr(), assign_plist_from_db()  \n"
		"\n"
		""},
	 { "PS_dot_plot", (PyCFunction)(void(*)(void))_wrap_PS_dot_plot, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Produce postscript dot-plot.  \n"
		"\n"
		"Wrapper to PS_dot_plot_list  \n"
		"\n"
		"Reads base pair probabilities produced by pf_fold() from the global array pr and the pair list\n"
		"base_pair produced by fold() and produces a postscript \"dot plot\" that is written to 'filename'.\n"
		"The \"dot plot\" represents each base pairing probability by a square of corresponding area in a\n"
		"upper triangle matrix. The lower part of the matrix contains the minimum free energy  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is deprecated and will be removed soon! Use PS_dot_plot_list() instead!  \n"
		"\n"
		"Note\n"
		"----\n"
		"DO NOT USE THIS FUNCTION ANYMORE SINCE IT IS NOT THREADSAFE  \n"
		"\n"
		""},
	 { "hc_type_get", _wrap_hc_type_get, METH_O, NULL},
	 { "hc_n_get", _wrap_hc_n_get, METH_O, NULL},
	 { "hc_mx_get", _wrap_hc_mx_get, METH_O, NULL},
	 { "hc_up_ext_get", _wrap_hc_up_ext_get, METH_O, NULL},
	 { "hc_up_hp_get", _wrap_hc_up_hp_get, METH_O, NULL},
	 { "hc_up_int_get", _wrap_hc_up_int_get, METH_O, NULL},
	 { "hc_up_ml_get", _wrap_hc_up_ml_get, METH_O, NULL},
	 { "new_hc", _wrap_new_hc, METH_NOARGS, "\n"
		"\n"
		"\n"
		"The hard constraints data structure.  \n"
		"\n"
		"The content of this data structure determines the decomposition pattern used in the folding\n"
		"recursions. Attribute 'matrix' is used as source for the branching pattern of the decompositions\n"
		"during all folding recursions. Any entry in matrix[i,j] consists of the 6 LSB that allows one to\n"
		"distinguish the following types of base pairs:  \n"
		"\n"
		"*   in the exterior loop (RNA.CONSTRAINT_CONTEXT_EXT_LOOP)  \n"
		"*   enclosing a hairpin (RNA.CONSTRAINT_CONTEXT_HP_LOOP)  \n"
		"*   enclosing an internal loop (RNA.CONSTRAINT_CONTEXT_INT_LOOP)  \n"
		"*   enclosed by an exterior loop (RNA.CONSTRAINT_CONTEXT_INT_LOOP_ENC)  \n"
		"*   enclosing a multi branch loop (RNA.CONSTRAINT_CONTEXT_MB_LOOP)  \n"
		"*   enclosed by a multi branch loop (RNA.CONSTRAINT_CONTEXT_MB_LOOP_ENC)  \n"
		"\n"
		"The four linear arrays 'up_xxx' provide the number of available unpaired nucleotides (including\n"
		"position i) 3' of each position in the sequence.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.hc_init(), RNA.hc_free(), RNA.CONSTRAINT_CONTEXT_EXT_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_HP_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_INT_LOOP, RNA.CONSTRAINT_CONTEXT_MB_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_MB_LOOP_ENC  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"type : vrna_hc_type_e  \n"
		"\n"
		"n : unsigned int  \n"
		"\n"
		"strands : unsigned int  \n"
		"\n"
		"sn : unsigned int *  \n"
		"\n"
		"state : unsigned char  \n"
		"\n"
		"mx : unsigned char *  \n"
		"\n"
		"matrix_local : unsigned char **  \n"
		"\n"
		"up_ext : unsigned int *  \n"
		"    A linear array that holds the number of allowed unpaired nucleotides in an exterior loop.  \n"
		"\n"
		"up_hp : unsigned int *  \n"
		"    A linear array that holds the number of allowed unpaired nucleotides in a hairpin loop.  \n"
		"\n"
		"up_int : unsigned int *  \n"
		"    A linear array that holds the number of allowed unpaired nucleotides in an internal loop.  \n"
		"\n"
		"up_ml : unsigned int *  \n"
		"    A linear array that holds the number of allowed unpaired nucleotides in a multi branched loop.  \n"
		"\n"
		"f : vrna_hc_eval_f  \n"
		"    A function pointer that returns whether or not a certain decomposition may be evaluated.  \n"
		"\n"
		"data : void *  \n"
		"    A pointer to some structure where the user may store necessary data to evaluate its generic hard\n"
		"    constraint function.  \n"
		"\n"
		"free_data : vrna_auxdata_free_f  \n"
		"    A pointer to a function to free memory occupied by auxiliary data.  \n"
		"\n"
		"    The function this pointer is pointing to will be called upon destruction of the RNA.hc(), and\n"
		"    provided with the RNA.hc().data pointer that may hold auxiliary data. Hence, to avoid leaking\n"
		"    memory, the user may use this pointer to free memory occupied by auxiliary data.  \n"
		"\n"
		"depot : vrna_hc_depot_t *  \n"
		"\n"
		"eval_ext : vrna_hc_eval_loop_f  \n"
		"\n"
		"eval_hp : vrna_hc_eval_hp_f  \n"
		"\n"
		"eval_int : vrna_hc_eval_int_f  \n"
		"\n"
		"eval_mb : vrna_hc_eval_loop_f  \n"
		"\n"
		""},
	 { "delete_hc", _wrap_delete_hc, METH_O, NULL},
	 { "hc_swigregister", hc_swigregister, METH_O, NULL},
	 { "hc_swiginit", hc_swiginit, METH_VARARGS, NULL},
	 { "new_sc_mod_param", (PyCFunction)(void(*)(void))_wrap_new_sc_mod_param, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Attributes\n"
		"----------\n"
		"available : unsigned int  \n"
		"\n"
		"name : char *  \n"
		"\n"
		"one_letter_code : char  \n"
		"\n"
		"unmodified : char  \n"
		"\n"
		"fallback : char  \n"
		"\n"
		"pairing_partners : char  \n"
		"\n"
		"pairing_partners_encoding : unsigned int  \n"
		"\n"
		"unmodified_encoding : unsigned int  \n"
		"\n"
		"fallback_encoding : unsigned int  \n"
		"\n"
		"num_ptypes : size_t  \n"
		"\n"
		"ptypes : size_t  \n"
		"\n"
		"stack_dG : int  \n"
		"\n"
		"stack_dH : int  \n"
		"\n"
		"dangle5_dG : int  \n"
		"\n"
		"dangle5_dH : int  \n"
		"\n"
		"dangle3_dG : int  \n"
		"\n"
		"dangle3_dH : int  \n"
		"\n"
		"mismatch_dG : int  \n"
		"\n"
		"mismatch_dH : int  \n"
		"\n"
		"terminal_dG : int  \n"
		"\n"
		"terminal_dH : int  \n"
		"\n"
		""},
	 { "delete_sc_mod_param", _wrap_delete_sc_mod_param, METH_O, NULL},
	 { "sc_mod_param_swigregister", sc_mod_param_swigregister, METH_O, NULL},
	 { "sc_mod_param_swiginit", sc_mod_param_swiginit, METH_VARARGS, NULL},
	 { "sc_mod_read_from_jsonfile", (PyCFunction)(void(*)(void))_wrap_sc_mod_read_from_jsonfile, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Parse and extract energy parameters for a modified base from a JSON file.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as an overloaded function `sc_mod_read_from_jsonfile()` where the\n"
		"    `md` parameter may be omitted and defaults to `NULL`. See, e.g.\n"
		"    :py:func:`RNA.sc_mod_read_from_jsonfile()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : const char *\n"
		"    The JSON file containing the specifications of the modified base  \n"
		"md : RNA.md() *\n"
		"    A model-details data structure (for look-up of canonical base pairs)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.sc_mod_param()  \n"
		"    Parameters of the modified base  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.sc_mod_read_from_json(), RNA.sc_mod_parameters_free(), RNA.fold_compound.sc_mod(), modified-\n"
		"bases-params  \n"
		"\n"
		""},
	 { "sc_mod_read_from_json", (PyCFunction)(void(*)(void))_wrap_sc_mod_read_from_json, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Parse and extract energy parameters for a modified base from a JSON string.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as an overloaded function `sc_mod_read_from_json()` where the `md`\n"
		"    parameter may be omitted and defaults to `NULL`. See, e.g.\n"
		"    :py:func:`RNA.sc_mod_read_from_json()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename :\n"
		"    The JSON file containing the specifications of the modified base  \n"
		"md : RNA.md() *\n"
		"    A model-details data structure (for look-up of canonical base pairs)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.sc_mod_param()  \n"
		"    Parameters of the modified base  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.sc_mod_read_from_jsonfile(), RNA.sc_mod_parameters_free(), RNA.fold_compound.sc_mod(), modified-\n"
		"bases-\n"
		"params  \n"
		"\n"
		""},
	 { "sc_mod_parameters_free", (PyCFunction)(void(*)(void))_wrap_sc_mod_parameters_free, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Release memory occupied by a modified base parameter data structure.  \n"
		"\n"
		"Properly free a RNA.sc_mod_param() data structure  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"params : RNA.sc_mod_param()\n"
		"    The data structure to free  \n"
		"\n"
		""},
	 { "probing_data_linear", (PyCFunction)(void(*)(void))_wrap_probing_data_linear, METH_VARARGS|METH_KEYWORDS, "probing_data_linear(DoubleVector data, DoubleVector data_weights, PyObject * strategy_cb, PyObject * strategy_cb_options=Py_None, PyObject * strategy_cb_options_free=Py_None, unsigned int options=) -> probing_data"},
	 { "new_probing_data", _wrap_new_probing_data, METH_VARARGS, "\n"
		"probing_data(reactivities, m, b, transform_f=Py_None, transform_data=Py_None, data_free_f=Py_None)\n"
		"probing_data(reactivities, beta, pr_conversion=, pr_default=)\n"
		"probing_data(reactivities, temperature, options=, unpaired_data={}, paired_data={}, transform_f=Py_None, transform_data=Py_None, data_free_f=Py_None)\n"
		"probing_data(DoubleVector reactivities, double m, double b)\n"
		"probing_data(DoubleDoubleVector reactivities, DoubleVector ms, DoubleVector bs)\n"
		"probing_data(DoubleDoubleVector reactivities, DoubleVector betas, StringVector pr_conversions=std::vector< std::string >(), DoubleVector pr_defaults=std::vector< double >())\n"
		"new_probing_data(DoubleVector reactivities, double temperature, unsigned char options, DoubleVector unpaired_data={}, DoubleVector paired_data={}) -> probing_data\n"
		"The :py:func:`probing_data` constructor can be invoked in different ways.\n"
		"Depending on the input parameters, the object returned will invoke\n"
		"particular probing data integration methods either for single\n"
		"sequences or multiple sequence alignments. Hence, it subsumes and\n"
		"provides an easy interface for the functions\n"
		":py:func:`probing_data_deigan`, :py:func:`probing_data_deigan_comparative`,\n"
		"etc.\n"
		"\n"
		"\n"
		"When multiple sets of probing data are supplied, the constructor\n"
		"assumes preparations for multiple sequence alignments (MSAs). As\n"
		"a consequence, the parameters for the conversion methods must be\n"
		"supplied as lists of parameters, one for each sequence. \n"
		"\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"reactivities: list(double) or list(list(double)\n"
		"    single sequence probing data (1-based) or multiple sequence probing data (0-based list for each sequence of 1-based data)\n"
		"m: double\n"
		"    slope for the Deigan et al. 2009 method\n"
		"b: double\n"
		"    intercept for the Deigan et al. 2009 method\n"
		"ms: list(double)\n"
		"    multiple slopes for the Deigan et al. 2009 method (0-based, one for each sequence)\n"
		"bs: list(double)\n"
		"    multiple intercepts for the Deigan et al. 2009 method (0-based, one for each sequence)\n"
		"beta: double\n"
		"    scaling factor for Zarringhalam et al. 2012 method\n"
		"betas: double\n"
		"    multiple scaling factors for Zarringhalam et al. 2012 method (0-based, one for each sequence)\n"
		"pr_conversion: string\n"
		"    probing data to conversion strategy \n"
		"pr_conversions: list(string)\n"
		"    multiple probing data to conversion strategies (0-based, one for each sequence)\n"
		"pr_default: double\n"
		"    default probability for a nucleotide where reactivity data is missing for\n"
		"pr_defaults: list(double)\n"
		"    list of default probabilities for a nucleotide where reactivity data is missing for (0-based, one for each sequence)\n"
		"\n"
		""},
	 { "delete_probing_data", _wrap_delete_probing_data, METH_O, NULL},
	 { "probing_data_probing_data_linear_num", _wrap_probing_data_probing_data_linear_num, METH_O, NULL},
	 { "probing_data_probing_data_linear_raw", (PyCFunction)(void(*)(void))_wrap_probing_data_probing_data_linear_raw, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "probing_data_probing_data_linear_weight", (PyCFunction)(void(*)(void))_wrap_probing_data_probing_data_linear_weight, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "probing_data_probing_data_linear_energies", (PyCFunction)(void(*)(void))_wrap_probing_data_probing_data_linear_energies, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "probing_data_swigregister", probing_data_swigregister, METH_O, NULL},
	 { "probing_data_swiginit", probing_data_swiginit, METH_VARARGS, NULL},
	 { "probing_data_deigan", (PyCFunction)(void(*)(void))_wrap_probing_data_deigan, METH_VARARGS|METH_KEYWORDS, "probing_data_deigan(DoubleVector reactivities, double m, double b) -> probing_data"},
	 { "probing_data_deigan_comparative", (PyCFunction)(void(*)(void))_wrap_probing_data_deigan_comparative, METH_VARARGS|METH_KEYWORDS, "probing_data_deigan_comparative(DoubleDoubleVector reactivities, DoubleVector ms, DoubleVector bs, unsigned int multi_params=) -> probing_data"},
	 { "probing_data_zarringhalam", (PyCFunction)(void(*)(void))_wrap_probing_data_zarringhalam, METH_VARARGS|METH_KEYWORDS, "probing_data_zarringhalam(DoubleVector reactivities, double beta, std::string pr_conversion=, double pr_default=) -> probing_data"},
	 { "probing_data_zarringhalam_comparative", (PyCFunction)(void(*)(void))_wrap_probing_data_zarringhalam_comparative, METH_VARARGS|METH_KEYWORDS, "probing_data_zarringhalam_comparative(DoubleDoubleVector reactivities, DoubleVector betas, StringVector pr_conversions=std::vector< std::string >(), DoubleVector pr_defaults=std::vector< double >(), unsigned int multi_params=) -> probing_data"},
	 { "probing_data_eddy", (PyCFunction)(void(*)(void))_wrap_probing_data_eddy, METH_VARARGS|METH_KEYWORDS, "probing_data_eddy(DoubleVector reactivities, double temperature, unsigned char options=, DoubleVector unpaired_data={}, DoubleVector paired_data={}) -> probing_data"},
	 { "probing_data_eddy_comparative", (PyCFunction)(void(*)(void))_wrap_probing_data_eddy_comparative, METH_VARARGS|METH_KEYWORDS, "probing_data_eddy_comparative(DoubleDoubleVector reactivities, double temperature, unsigned char options=, DoubleDoubleVector unpaired_data={}, DoubleDoubleVector paired_data={}, unsigned int multi_params=) -> probing_data"},
	 { "probing_data_free", (PyCFunction)(void(*)(void))_wrap_probing_data_free, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Free memory occupied by the (prepared) probing data.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.probing_data(), RNA.fold_compound.sc_probing(), RNA.probing_data_deigan(),\n"
		"RNA.probing_data_deigan_comparative(), RNA.probing_data_zarringhalam(),\n"
		"RNA.probing_data_zarringhalam_comparative(), RNA.probing_data_eddy(),\n"
		"RNA.probing_data_eddy_comparative()  \n"
		"\n"
		""},
	 { "eval_structure_simple", _wrap_eval_structure_simple, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA and print contributions per loop.  \n"
		"\n"
		"This function allows for detailed energy evaluation of a given sequence/structure pair. In contrast\n"
		"to RNA.fold_compound.eval_structure() this function prints detailed energy contributions based on individual\n"
		"loops to a file handle. If NULL is passed as file handle, this function defaults to print to stdout.\n"
		"Any positive `verbosity_level` activates potential warning message of the energy evaluting\n"
		"functions, while values :math:`\\ge 1` allow for detailed control of what data is printed. A\n"
		"negative parameter `verbosity_level` turns off printing all together.  \n"
		"\n"
		"In contrast to RNA.fold_compound.eval_structure_verbose() this function assumes default model details and default\n"
		"energy parameters in order to evaluate the free energy of the secondary structure. Threefore, it\n"
		"serves as a simple interface function for energy evaluation for situations where no changes on the\n"
		"energy model are required.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available through an overloaded version of RNA.eval_structure_simple(). The\n"
		"    last two arguments for this function are optional and default to RNA.VERBOSITY_QUIET and\n"
		"    `NULL`, respectively. See, e.g.    :py:func:`RNA.eval_structure_simple()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence in uppercase letters  \n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket notation  \n"
		"verbosity_level : int\n"
		"    The level of verbosity of this function  \n"
		"file : FILE *\n"
		"    A file handle where this function should print to (may be NULL).  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_structure_verbose(), RNA.fold_compound.eval_structure_pt(),\n"
		"RNA.fold_compound.eval_structure_pt_verbose(),  \n"
		"\n"
		""},
	 { "eval_circ_structure", _wrap_eval_circ_structure, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Evaluate free energy of a sequence/structure pair, assume sequence to be circular and print\n"
		"contributions per loop.  \n"
		"\n"
		"This function is the same as RNA.eval_structure_simple_v() but assumes the input sequence to be\n"
		"circularized.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available through an overloaded version of RNA.eval_circ_structure(). The last\n"
		"    two arguments for this function are optional and default to RNA.VERBOSITY_QUIET and `NULL`,\n"
		"    respectively. See, e.g.    :py:func:`RNA.eval_circ_structure()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence in uppercase letters  \n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket notation  \n"
		"verbosity_level : int\n"
		"    The level of verbosity of this function  \n"
		"file : FILE *\n"
		"    A file handle where this function should print to (may be NULL).  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.eval_structure_simple_v(), RNA.eval_circ_structure(), RNA.fold_compound.eval_structure_verbose()  \n"
		"\n"
		""},
	 { "eval_gquad_structure", _wrap_eval_gquad_structure, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Evaluate free energy of a sequence/structure pair, allow for G-Quadruplexes in the structure and\n"
		"print contributions per loop.  \n"
		"\n"
		"This function is the same as RNA.eval_structure_simple_v() but allows for annotated G-Quadruplexes\n"
		"in the dot-bracket structure input.  \n"
		"\n"
		"G-Quadruplexes are annotated as plus signs ('+') for each G involved in the motif. Linker sequences\n"
		"must be denoted by dots ('.') as they are considered unpaired. Below is an example of a 2-layer\n"
		"G-quadruplex:  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available through an overloaded version of RNA.eval_gquad_structure(). The\n"
		"    last two arguments for this function are optional and default to RNA.VERBOSITY_QUIET and\n"
		"    `NULL`, respectively. See, e.g.    :py:func:`RNA.eval_gquad_structure()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence in uppercase letters  \n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket notation  \n"
		"verbosity_level : int\n"
		"    The level of verbosity of this function  \n"
		"file : FILE *\n"
		"    A file handle where this function should print to (may be NULL).  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.eval_structure_simple_v(), RNA.eval_gquad_structure(),\n"
		"RNA.fold_compound.eval_structure_verbose()  \n"
		"\n"
		""},
	 { "eval_circ_gquad_structure", _wrap_eval_circ_gquad_structure, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Evaluate free energy of a sequence/structure pair, assume sequence to be circular, allow for\n"
		"G-Quadruplexes in the structure, and print contributions per loop.  \n"
		"\n"
		"This function is the same as RNA.eval_structure_simple_v() but assumes the input sequence to be\n"
		"circular and allows for annotated G-Quadruplexes in the dot-bracket structure input.  \n"
		"\n"
		"G-Quadruplexes are annotated as plus signs ('+') for each G involved in the motif. Linker sequences\n"
		"must be denoted by dots ('.') as they are considered unpaired. Below is an example of a 2-layer\n"
		"G-quadruplex:  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available through an overloaded version of RNA.eval_circ_gquad_structure().\n"
		"    The last two arguments for this function are optional and default to RNA.VERBOSITY_QUIET and\n"
		"    `NULL`, respectively. See, e.g.    :py:func:`RNA.eval_circ_gquad_structure()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence in uppercase letters  \n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket notation  \n"
		"verbosity_level : int\n"
		"    The level of verbosity of this function  \n"
		"file : FILE *\n"
		"    A file handle where this function should print to (may be NULL).  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		""},
	 { "eval_structure_pt_simple", _wrap_eval_structure_pt_simple, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA.  \n"
		"\n"
		"This function allows for energy evaluation of a given sequence/structure pair where the structure is\n"
		"provided in pair_table format as obtained from RNA.ptable(). Model details, energy parameters, and\n"
		"possibly soft constraints are used as provided via the parameter 'fc'. The fold_compound does not\n"
		"need to contain any DP matrices, but all the most basic init values as one would get from a call\n"
		"like this:  In contrast to RNA.fold_compound.eval_structure_pt_verbose() this function assumes default model\n"
		"details and default energy parameters in order to evaluate the free energy of the secondary\n"
		"structure. Threefore, it serves as a simple interface function for energy evaluation for situations\n"
		"where no changes on the energy model are required.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence in uppercase letters  \n"
		"pt : const short *\n"
		"    Secondary structure as pair_table  \n"
		"verbosity_level : int\n"
		"    The level of verbosity of this function  \n"
		"file : FILE *\n"
		"    A file handle where this function should print to (may be NULL).  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The free energy of the input structure given the input sequence in 10cal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.ptable(), RNA.eval_structure_pt_v(), RNA.eval_structure_simple()  \n"
		"\n"
		""},
	 { "energy_of_structure", (PyCFunction)(void(*)(void))_wrap_energy_of_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA using global model detail settings.  \n"
		"\n"
		"If verbosity level is set to a value >0, energies of structure elements are printed to stdout  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.eval_structure() or RNA.fold_compound.eval_structure_verbose() instead!  \n"
		"\n"
		"Note\n"
		"----\n"
		"OpenMP: This function relies on several global model settings variables and thus is not to be\n"
		"considered threadsafe. See energy_of_struct_par() for a completely threadsafe implementation.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"structure : const char *\n"
		"    secondary structure in dot-bracket notation  \n"
		"verbosity_level : int\n"
		"    a flag to turn verbose output on/off  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_structure()  \n"
		"\n"
		""},
	 { "energy_of_circ_structure", (PyCFunction)(void(*)(void))_wrap_energy_of_circ_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded circular RNA.  \n"
		"\n"
		"\n"
		"If verbosity level is set to a value >0, energies of structure elements are printed to stdout  \n"
		"\n"
		"Note\n"
		"----\n"
		"OpenMP: This function relies on several global model settings variables and thus is not to be\n"
		"considered threadsafe. See energy_of_circ_struct_par() for a completely threadsafe implementation.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.eval_structure() or RNA.fold_compound.eval_structure_verbose() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket notation  \n"
		"verbosity_level : int\n"
		"    A flag to turn verbose output on/off  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_structure()  \n"
		"\n"
		""},
	 { "energy_of_gquad_structure", (PyCFunction)(void(*)(void))_wrap_energy_of_gquad_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "energy_of_structure_pt", (PyCFunction)(void(*)(void))_wrap_energy_of_structure_pt, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA.  \n"
		"\n"
		"If verbosity level is set to a value >0, energies of structure elements are printed to stdout  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.eval_structure_pt() or RNA.fold_compound.eval_structure_pt_verbose()\n"
		"    instead!  \n"
		"\n"
		"Note\n"
		"----\n"
		"OpenMP: This function relies on several global model settings variables and thus is not to be\n"
		"considered threadsafe. See energy_of_struct_pt_par() for a completely threadsafe implementation.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"ptable : short *\n"
		"    the pair table of the secondary structure  \n"
		"s : short *\n"
		"    encoded RNA sequence  \n"
		"s1 : short *\n"
		"    encoded RNA sequence  \n"
		"verbosity_level : int\n"
		"    a flag to turn verbose output on/off  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    the free energy of the input structure given the input sequence in 10kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_structure_pt()  \n"
		"\n"
		""},
	 { "energy_of_move", (PyCFunction)(void(*)(void))_wrap_energy_of_move, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate energy of a move (closing or opening of a base pair).  \n"
		"\n"
		"If the parameters m1 and m2 are negative, it is deletion (opening) of a base pair, otherwise it is\n"
		"insertion (opening).  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.eval_move() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"structure : const char *\n"
		"    secondary structure in dot-bracket notation  \n"
		"m1 : int\n"
		"    first coordinate of base pair  \n"
		"m2 : int\n"
		"    second coordinate of base pair  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    energy change of the move in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_move()  \n"
		"\n"
		""},
	 { "energy_of_move_pt", (PyCFunction)(void(*)(void))_wrap_energy_of_move_pt, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate energy of a move (closing or opening of a base pair).  \n"
		"\n"
		"If the parameters m1 and m2 are negative, it is deletion (opening) of a base pair, otherwise it is\n"
		"insertion (opening).  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.eval_move_pt() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : short *\n"
		"    the pair table of the secondary structure  \n"
		"s : short *\n"
		"    encoded RNA sequence  \n"
		"s1 : short *\n"
		"    encoded RNA sequence  \n"
		"m1 : int\n"
		"    first coordinate of base pair  \n"
		"m2 : int\n"
		"    second coordinate of base pair  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    energy change of the move in 10cal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_move_pt()  \n"
		"\n"
		""},
	 { "loop_energy", (PyCFunction)(void(*)(void))_wrap_loop_energy, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate energy of a loop.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.eval_loop_pt() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ptable : short *\n"
		"    the pair table of the secondary structure  \n"
		"s : short *\n"
		"    encoded RNA sequence  \n"
		"s1 : short *\n"
		"    encoded RNA sequence  \n"
		"i : int\n"
		"    position of covering base pair  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    free energy of the loop in 10cal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_loop_pt()  \n"
		"\n"
		""},
	 { "energy_of_struct", (PyCFunction)(void(*)(void))_wrap_energy_of_struct, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is deprecated and should not be used in future programs! Use energy_of_structure()\n"
		"    instead!  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is not entirely threadsafe! Depending on the state of the global variable eos_debug it\n"
		"prints energy information to stdout or not...  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"structure : const char *\n"
		"    secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"energy_of_structure, energy_of_circ_struct(), energy_of_struct_pt()  \n"
		"\n"
		""},
	 { "energy_of_struct_pt", (PyCFunction)(void(*)(void))_wrap_energy_of_struct_pt, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is deprecated and should not be used in future programs! Use\n"
		"    energy_of_structure_pt() instead!  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is not entirely threadsafe! Depending on the state of the global variable eos_debug it\n"
		"prints energy information to stdout or not...  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"ptable : short *\n"
		"    the pair table of the secondary structure  \n"
		"s : short *\n"
		"    encoded RNA sequence  \n"
		"s1 : short *\n"
		"    encoded RNA sequence  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    the free energy of the input structure given the input sequence in 10kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"make_pair_table(), energy_of_structure()  \n"
		"\n"
		""},
	 { "energy_of_circ_struct", (PyCFunction)(void(*)(void))_wrap_energy_of_circ_struct, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded circular RNA  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is deprecated and should not be used in future programs Use\n"
		"    energy_of_circ_structure() instead!  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is not entirely threadsafe! Depending on the state of the global variable eos_debug it\n"
		"prints energy information to stdout or not...  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"structure : const char *\n"
		"    secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"energy_of_circ_structure(), energy_of_struct(), energy_of_struct_pt()  \n"
		"\n"
		""},
	 { "E_Stem", (PyCFunction)(void(*)(void))_wrap_E_Stem, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute the energy contribution of a stem branching off a loop-region.  \n"
		"\n"
		"This function computes the energy contribution of a stem that branches off a loop region. This can\n"
		"be the case in multiloops, when a stem branching off increases the degree of the loop but also\n"
		"*immediately interior base pairs* of an exterior loop contribute free energy. To switch the behavior\n"
		"of the function according to the evaluation of a multiloop- or exterior-loop-stem, you pass the flag\n"
		"'extLoop'. The returned energy contribution consists of a TerminalAU penalty if the pair type is\n"
		"greater than 2, dangling end contributions of mismatching nucleotides adjacent to the stem if only\n"
		"one of the si1, sj1 parameters is greater than 0 and mismatch energies if both mismatching\n"
		"nucleotides are positive values. Thus, to avoid incorporating dangling end or mismatch energies just\n"
		"pass a negative number, e.g. -1 to the mismatch argument.  \n"
		"\n"
		"This is an illustration of how the energy contribution is assembled:\n"
		"      3'  5'\n"
		"      |   |\n"
		"      X - Y\n"
		"5'-si1     sj1-3'  \n"
		"\n"
		"Here, (X,Y) is the base pair that closes the stem that branches off a loop region. The nucleotides\n"
		"si1 and sj1 are the 5'- and 3'- mismatches, respectively. If the base pair type of (X,Y) is greater\n"
		"than 2 (i.e. an A-U or G-U pair, the TerminalAU penalty will be included in the energy contribution\n"
		"returned. If si1 and sj1 are both nonnegative numbers, mismatch energies will also be included. If\n"
		"one of si1 or sj1 is a negative value, only 5' or 3' dangling end contributions are taken into\n"
		"account. To prohibit any of these mismatch contributions to be incorporated, just pass a negative\n"
		"number to both, si1 and sj1. In case the argument extLoop is 0, the returned energy contribution\n"
		"also includes the *internal-loop-penalty* of a multiloop stem with closing pair type.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Please use one of the functions RNA.E_exterior_stem() and RNA.E_multibranch_stem() instead!\n"
		"    Use the former for cases where `extLoop` != 0 and the latter otherwise.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.E_multibranch_stem(), _ExtLoop()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is threadsafe  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type : int\n"
		"    The pair type of the first base pair un the stem  \n"
		"si1 : int\n"
		"    The 5'-mismatching nucleotide  \n"
		"sj1 : int\n"
		"    The 3'-mismatching nucleotide  \n"
		"extLoop : int\n"
		"    A flag that indicates whether the contribution reflects the one of an exterior loop or not  \n"
		"P : RNA.param() *\n"
		"    The data structure containing scaled energy parameters  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The Free energy of the branch off the loop in dcal/mol  \n"
		"\n"
		""},
	 { "E_ExtLoop", (PyCFunction)(void(*)(void))_wrap_E_ExtLoop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "exp_E_ExtLoop", (PyCFunction)(void(*)(void))_wrap_exp_E_ExtLoop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"This is the partition function variant of E_ExtLoop()  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.exp_E_ext_stem() instead!  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"FLT_OR_DBL  \n"
		"    The Boltzmann weighted energy contribution of the introduced exterior-loop stem  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"E_ExtLoop()  \n"
		"\n"
		""},
	 { "exp_E_Stem", (PyCFunction)(void(*)(void))_wrap_exp_E_Stem, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute the Boltzmann weighted energy contribution of a stem branching off a loop-region\n"
		"----------------------------------------------------------------------------------------  \n"
		"This is the partition function variant of E_Stem()  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"FLT_OR_DBL  \n"
		"    The Boltzmann weighted energy contribution of the branch off the loop  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"E_Stem()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is threadsafe  \n"
		"\n"
		""},
	 { "E_Hairpin", (PyCFunction)(void(*)(void))_wrap_E_Hairpin, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute the Energy of a hairpin-loop.  \n"
		"\n"
		"To evaluate the free energy of a hairpin-loop, several parameters have to be known. A general\n"
		"hairpin-loop has this structure:  \n"
		"      a3 a4\n"
		"    a2     a5\n"
		"    a1     a6\n"
		"      X - Y\n"
		"      |   |\n"
		"      5'  3'\n"
		" where X-Y marks the closing pair [e.g. a **(G,C)** pair]. The length of this loop is 6 as there are\n"
		" six unpaired nucleotides (a1-a6) enclosed by (X,Y). The 5' mismatching nucleotide is a1 while the\n"
		" 3' mismatch is a6. The nucleotide sequence of this loop is \"a1.a2.a3.a4.a5.a6\"  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"size : int\n"
		"    The size of the loop (number of unpaired nucleotides)  \n"
		"type : int\n"
		"    The pair type of the base pair closing the hairpin  \n"
		"si1 : int\n"
		"    The 5'-mismatching nucleotide  \n"
		"sj1 : int\n"
		"    The 3'-mismatching nucleotide  \n"
		"string : const char *\n"
		"    The sequence of the loop (May be `NULL`, otherwise mst be at least :math:`size + 2` long)  \n"
		"P : RNA.param() *\n"
		"    The datastructure containing scaled energy parameters  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The Free energy of the Hairpin-loop in dcal/mol  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Not (really) thread safe! A threadsafe implementation will replace this function in a future\n"
		"release!  \n"
		" Energy evaluation may change due to updates in global variable \"tetra_loop\"  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"scale_parameters(), RNA.param()  \n"
		"\n"
		"Note\n"
		"----\n"
		"The parameter sequence should contain the sequence of the loop in capital letters of the nucleic\n"
		"acid alphabet if the loop size is below 7. This is useful for unusually stable tri-, tetra- and\n"
		"hexa-loops which are treated differently (based on experimental data) if they are tabulated.  \n"
		"\n"
		""},
	 { "exp_E_Hairpin", (PyCFunction)(void(*)(void))_wrap_exp_E_Hairpin, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute Boltzmann weight :math:`e^{-\\Delta G/kT}` of a hairpin loop.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"u : int\n"
		"    The size of the loop (number of unpaired nucleotides)  \n"
		"type : int\n"
		"    The pair type of the base pair closing the hairpin  \n"
		"si1 : short\n"
		"    The 5'-mismatching nucleotide  \n"
		"sj1 : short\n"
		"    The 3'-mismatching nucleotide  \n"
		"string : const char *\n"
		"    The sequence of the loop (May be `NULL`, otherwise mst be at least :math:`size + 2` long)  \n"
		"P : RNA.exp_param() *\n"
		"    The datastructure containing scaled Boltzmann weights of the energy parameters  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"FLT_OR_DBL  \n"
		"    The Boltzmann weight of the Hairpin-loop  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Not (really) thread safe! A threadsafe implementation will replace this function in a future\n"
		"release!  \n"
		" Energy evaluation may change due to updates in global variable \"tetra_loop\"  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"get_scaled_pf_parameters(), RNA.exp_param(), E_Hairpin()  \n"
		"\n"
		"Note\n"
		"----\n"
		"multiply by scale[u+2]  \n"
		"\n"
		""},
	 { "E_IntLoop", (PyCFunction)(void(*)(void))_wrap_E_IntLoop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute the Energy of an internal-loop\n"
		"--------------------------------------  \n"
		"This function computes the free energy :math:`\\Delta G` of an internal-loop with the following\n"
		"structure:  \n"
		"      3'  5'\n"
		"      |   |\n"
		"      U - V\n"
		"  a_n       b_1\n"
		"   .        .\n"
		"   .        .\n"
		"   .        .\n"
		"  a_1       b_m\n"
		"      X - Y\n"
		"      |   |\n"
		"      5'  3'\n"
		" This general structure depicts an internal-loop that is closed by the base pair (X,Y). The enclosed\n"
		" base pair is (V,U) which leaves the unpaired bases a_1-a_n and b_1-b_n that constitute the loop. In\n"
		" this example, the length of the internal-loop is :math:`(n+m)` where n or m may be 0 resulting in a\n"
		" bulge-loop or base pair stack. The mismatching nucleotides for the closing pair (X,Y) are:  \n"
		" 5'-mismatch: a_1  \n"
		" 3'-mismatch: b_m  \n"
		" and for the enclosed base pair (V,U):  \n"
		" 5'-mismatch: b_1  \n"
		" 3'-mismatch: a_n  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"n1 : int\n"
		"    The size of the 'left'-loop (number of unpaired nucleotides)  \n"
		"n2 : int\n"
		"    The size of the 'right'-loop (number of unpaired nucleotides)  \n"
		"type : int\n"
		"    The pair type of the base pair closing the internal loop  \n"
		"type_2 : int\n"
		"    The pair type of the enclosed base pair  \n"
		"si1 : int\n"
		"    The 5'-mismatching nucleotide of the closing pair  \n"
		"sj1 : int\n"
		"    The 3'-mismatching nucleotide of the closing pair  \n"
		"sp1 : int\n"
		"    The 3'-mismatching nucleotide of the enclosed pair  \n"
		"sq1 : int\n"
		"    The 5'-mismatching nucleotide of the enclosed pair  \n"
		"P : RNA.param() *\n"
		"    The datastructure containing scaled energy parameters  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The Free energy of the Interior-loop in dcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"scale_parameters(), RNA.param()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Base pairs are always denoted in 5'->3' direction. Thus the enclosed base pair must be 'turned\n"
		"arround' when evaluating the free energy of the internal-loop  \n"
		" This function is threadsafe  \n"
		"\n"
		""},
	 { "exp_E_IntLoop", (PyCFunction)(void(*)(void))_wrap_exp_E_IntLoop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute Boltzmann weight :math:`e^{-\\Delta G/kT}` of internal loop\n"
		"-------------------------------------------------------------------  \n"
		"multiply by scale[u1+u2+2] for scaling  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"u1 : int\n"
		"    The size of the 'left'-loop (number of unpaired nucleotides)  \n"
		"u2 : int\n"
		"    The size of the 'right'-loop (number of unpaired nucleotides)  \n"
		"type : int\n"
		"    The pair type of the base pair closing the internal loop  \n"
		"type2 : int\n"
		"    The pair type of the enclosed base pair  \n"
		"si1 : short\n"
		"    The 5'-mismatching nucleotide of the closing pair  \n"
		"sj1 : short\n"
		"    The 3'-mismatching nucleotide of the closing pair  \n"
		"sp1 : short\n"
		"    The 3'-mismatching nucleotide of the enclosed pair  \n"
		"sq1 : short\n"
		"    The 5'-mismatching nucleotide of the enclosed pair  \n"
		"P : RNA.exp_param() *\n"
		"    The datastructure containing scaled Boltzmann weights of the energy parameters  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"FLT_OR_DBL  \n"
		"    The Boltzmann weight of the Interior-loop  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"get_scaled_pf_parameters(), RNA.exp_param(), E_IntLoop()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is threadsafe  \n"
		"\n"
		""},
	 { "E_IntLoop_Co", (PyCFunction)(void(*)(void))_wrap_E_IntLoop_Co, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "__E_IntLoop_Co", (PyCFunction)(void(*)(void))_wrap___E_IntLoop_Co, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "ubf_eval_int_loop", (PyCFunction)(void(*)(void))_wrap_ubf_eval_int_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "ubf_eval_int_loop2", (PyCFunction)(void(*)(void))_wrap_ubf_eval_int_loop2, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "ubf_eval_ext_int_loop", (PyCFunction)(void(*)(void))_wrap_ubf_eval_ext_int_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "E_MLstem", (PyCFunction)(void(*)(void))_wrap_E_MLstem, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "exp_E_MLstem", (PyCFunction)(void(*)(void))_wrap_exp_E_MLstem, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "E_gquad", (PyCFunction)(void(*)(void))_wrap_E_gquad, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "exp_E_gquad", (PyCFunction)(void(*)(void))_wrap_exp_E_gquad, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "E_gquad_ali_en", (PyCFunction)(void(*)(void))_wrap_E_gquad_ali_en, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "exp_E_gquad_ali", (PyCFunction)(void(*)(void))_wrap_exp_E_gquad_ali, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "maximum_matching", (PyCFunction)(void(*)(void))_wrap_maximum_matching, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as global function `maximum_matching()`. See e.g.\n"
		"    :py:func:`RNA.maximum_matching()` in the :doc:`/api_python`.  \n"
		"\n"
		""},
	 { "fold", _wrap_fold, METH_VARARGS, "\n"
		"fold(string) -> (structure, mfe)fold(string) -> (structure, mfe)\n"
		"\n"
		"\n"
		"Compute Minimum Free Energy (MFE), and a corresponding secondary structure for an RNA sequence.  \n"
		"\n"
		"This simplified interface to RNA.fold_compound.mfe() computes the MFE and, if required, a secondary structure for\n"
		"an RNA sequence using default options. Memory required for dynamic programming (DP) matrices will be\n"
		"allocated and free'd on-the-fly. Hence, after return of this function, the recursively filled\n"
		"matrices are not available any more for any post-processing, e.g. suboptimal backtracking, etc.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `fold()` in the global namespace. The parameter\n"
		"    `structure` is returned along with the MFE und must not be provided. See e.g.\n"
		"    :py:func:`RNA.fold()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : const char *\n"
		"    RNA sequence  \n"
		"structure : char *\n"
		"    A pointer to the character array where the secondary structure in dot-bracket notation will be\n"
		"    written to  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the minimum free energy (MFE) in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.circfold(), RNA.fold_compound.mfe()  \n"
		"\n"
		"Note\n"
		"----\n"
		"In case you want to use the filled DP matrices for any subsequent post-processing step, or you\n"
		"require other conditions than specified by the default model details, use RNA.fold_compound.mfe(),\n"
		"and the data\n"
		"structure RNA.fold_compound() instead.  \n"
		"\n"
		""},
	 { "alifold", _wrap_alifold, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compute Minimum Free Energy (MFE), and a corresponding consensus secondary structure for an RNA\n"
		"sequence alignment using a comparative method.  \n"
		"\n"
		"This simplified interface to RNA.fold_compound.mfe() computes the MFE and, if required, a consensus secondary\n"
		"structure for an RNA sequence alignment using default options. Memory required for dynamic\n"
		"programming (DP) matrices will be allocated and free'd on-the-fly. Hence, after return of this\n"
		"function, the recursively filled matrices are not available any more for any post-processing, e.g.\n"
		"suboptimal backtracking, etc.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `alifold()` in the global namespace. The parameter\n"
		"    `structure` is returned along with the MFE und must not be provided. See e.g.\n"
		"    :py:func:`RNA.alifold()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequences : const char **\n"
		"    RNA sequence alignment  \n"
		"structure : char *\n"
		"    A pointer to the character array where the secondary structure in dot-bracket notation will be\n"
		"    written to  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the minimum free energy (MFE) in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.circalifold(), RNA.fold_compound.mfe()  \n"
		"\n"
		"Note\n"
		"----\n"
		"In case you want to use the filled DP matrices for any subsequent post-processing step, or you\n"
		"require other conditions than specified by the default model details, use RNA.fold_compound.mfe(),\n"
		"and the data\n"
		"structure RNA.fold_compound() instead.  \n"
		"\n"
		""},
	 { "cofold", _wrap_cofold, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compute Minimum Free Energy (MFE), and a corresponding secondary structure for two dimerized RNA\n"
		"sequences.  \n"
		"\n"
		"This simplified interface to RNA.fold_compound.mfe() computes the MFE and, if required, a secondary structure for\n"
		"two RNA sequences upon dimerization using default options. Memory required for dynamic programming\n"
		"(DP) matrices will be allocated and free'd on-the-fly. Hence, after return of this function, the\n"
		"recursively filled matrices are not available any more for any post-processing, e.g. suboptimal\n"
		"backtracking, etc.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is obsolete since RNA.mfe()/RNA.fold() can handle complexes multiple sequences\n"
		"    since v2.5.0. Use RNA.mfe()/RNA.fold() for connected component MFE instead and compute MFEs of\n"
		"    unconnected states separately.  \n"
		"\n"
		"Note\n"
		"----\n"
		"In case you want to use the filled DP matrices for any subsequent post-processing step, or you\n"
		"require other conditions than specified by the default model details, use RNA.fold_compound.mfe(),\n"
		"and the data\n"
		"structure RNA.fold_compound() instead.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `cofold()` in the global namespace. The parameter\n"
		"    `structure` is returned along with the MFE und must not be provided. See e.g.\n"
		"    :py:func:`RNA.cofold()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : const char *\n"
		"    two RNA sequences separated by the '&' character  \n"
		"structure : char *\n"
		"    A pointer to the character array where the secondary structure in dot-bracket notation will be\n"
		"    written to  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the minimum free energy (MFE) in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold(), RNA.fold_compound.mfe(), RNA.fold_compound(), RNA.fold_compound(),\n"
		"RNA.cut_point_insert()  \n"
		"\n"
		""},
	 { "circfold", _wrap_circfold, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compute Minimum Free Energy (MFE), and a corresponding secondary structure for a circular RNA\n"
		"sequence.  \n"
		"\n"
		"This simplified interface to RNA.fold_compound.mfe() computes the MFE and, if required, a secondary structure for\n"
		"a circular RNA sequence using default options. Memory required for dynamic programming (DP) matrices\n"
		"will be allocated and free'd on-the-fly. Hence, after return of this function, the recursively\n"
		"filled matrices are not available any more for any post-processing, e.g. suboptimal backtracking,\n"
		"etc.  \n"
		"\n"
		"Folding of circular RNA sequences is handled as a post-processing step of the forward recursions.\n"
		"See    :cite:t:`hofacker:2006`  for further details.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as function `circfold()` in the global namespace. The parameter\n"
		"    `structure` is returned along with the MFE und must not be provided. See e.g.\n"
		"    :py:func:`RNA.circfold()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : const char *\n"
		"    RNA sequence  \n"
		"structure : char *\n"
		"    A pointer to the character array where the secondary structure in dot-bracket notation will be\n"
		"    written to  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the minimum free energy (MFE) in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold(), RNA.fold_compound.mfe()  \n"
		"\n"
		"Note\n"
		"----\n"
		"In case you want to use the filled DP matrices for any subsequent post-processing step, or you\n"
		"require other conditions than specified by the default model details, use RNA.fold_compound.mfe(),\n"
		"and the data\n"
		"structure RNA.fold_compound() instead.  \n"
		"\n"
		""},
	 { "E_ml_rightmost_stem", (PyCFunction)(void(*)(void))_wrap_E_ml_rightmost_stem, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "get_gquad_L_matrix", (PyCFunction)(void(*)(void))_wrap_get_gquad_L_matrix, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "get_gquad_matrix", (PyCFunction)(void(*)(void))_wrap_get_gquad_matrix, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get a triangular matrix prefilled with minimum free energy contributions of G-quadruplexes.  \n"
		"\n"
		"At each position ij in the matrix, the minimum free energy of any G-quadruplex delimited by i and j\n"
		"is stored. If no G-quadruplex formation is possible, the matrix element is set to INF. Access the\n"
		"elements in the matrix via matrix[indx[j]+i]. To get the integer array indx see get_jindx().  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"S : short *\n"
		"    The encoded sequence  \n"
		"P : RNA.param() *\n"
		"    A pointer to the data structure containing the precomputed energy contributions  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int *  \n"
		"    A pointer to the G-quadruplex contribution matrix  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"get_jindx(), encode_sequence()  \n"
		"\n"
		""},
	 { "get_gquad_ali_matrix", (PyCFunction)(void(*)(void))_wrap_get_gquad_ali_matrix, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "E_GQuad_IntLoop_L_comparative", (PyCFunction)(void(*)(void))_wrap_E_GQuad_IntLoop_L_comparative, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "E_GQuad_IntLoop_L", (PyCFunction)(void(*)(void))_wrap_E_GQuad_IntLoop_L, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "free_arrays", _wrap_free_arrays, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Free arrays for mfe folding.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    See RNA.fold(), RNA.circfold(), or RNA.fold_compound.mfe() and RNA.fold_compound() for the usage\n"
		"    of the\n"
		"    new API!  \n"
		"\n"
		""},
	 { "update_fold_params", _wrap_update_fold_params, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Recalculate energy parameters.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    For non-default model settings use the new API with RNA.fold_compound.params_subst() and\n"
		"    RNA.fold_compound.mfe() instead!  \n"
		"\n"
		""},
	 { "circalifold", _wrap_circalifold, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compute MFE and according structure of an alignment of sequences assuming the sequences are circular\n"
		"instead of linear.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Usage of this function is discouraged! Use RNA.alicircfold(), and RNA.fold_compound.mfe()\n"
		"    instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"strings : const char **\n"
		"    A pointer to a NULL terminated array of character arrays  \n"
		"structure : char *\n"
		"    A pointer to a character array that may contain a constraining consensus structure (will be\n"
		"    overwritten by a consensus structure that exhibits the MFE)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy score in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.alicircfold(), RNA.alifold(), RNA.fold_compound.mfe()  \n"
		"\n"
		""},
	 { "free_alifold_arrays", _wrap_free_alifold_arrays, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Free the memory occupied by MFE alifold functions.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Usage of this function is discouraged! It only affects memory being free'd that was allocated by\n"
		"    an old API function before. Release of memory occupied by the newly introduced\n"
		"    RNA.fold_compound() is handled by RNA.fold_compound_free()  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound_free()  \n"
		"\n"
		""},
	 { "free_co_arrays", _wrap_free_co_arrays, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Free memory occupied by cofold().  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function will only free memory allocated by a prior call of cofold() or cofold_par(). See\n"
		"    RNA.fold_compound.mfe_dimer() for how to use the new API  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fc_destroy(), RNA.fold_compound.mfe_dimer()  \n"
		"\n"
		"Note\n"
		"----\n"
		"folding matrices now reside in the fold compound, and should be free'd there  \n"
		"\n"
		""},
	 { "update_cofold_params", _wrap_update_cofold_params, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Recalculate parameters.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    See RNA.fold_compound.params_subst() for an alternative using the new API  \n"
		"\n"
		""},
	 { "initialize_cofold", (PyCFunction)(void(*)(void))_wrap_initialize_cofold, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"allocate arrays for folding  \n"
		"\n"
		".. deprecated:: 2.7.2  \n"
		"\n"
		""},
	 { "Lfoldz", (PyCFunction)(void(*)(void))_wrap_Lfoldz, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Local MFE prediction using a sliding window approach with z-score cut-off (simplified interface).  \n"
		"\n"
		"This simplified interface to RNA.fold_compound.mfe_window_zscore() computes the MFE and locally optimal secondary\n"
		"structure using default options. Structures are predicted using a sliding window approach, where\n"
		"base pairs may not span outside the window. Memory required for dynamic programming (DP) matrices\n"
		"will be allocated and free'd on-the-fly. Hence, after return of this function, the recursively\n"
		"filled matrices are not available any more for any post-processing. This function is the z-score\n"
		"version of RNA.Lfold(), i.e. only predictions above a certain z-score cut-off value are printed.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    The nucleic acid sequence  \n"
		"window_size : int\n"
		"    The window size for locally optimal structures  \n"
		"min_z : double\n"
		"    The minimal z-score for a predicted structure to appear in the output  \n"
		"file : FILE *\n"
		"    The output file handle where predictions are written to (if NULL, output is written to stdout)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.mfe_window_zscore(), RNA.Lfold(), RNA.fold_compound.mfe_window()  \n"
		"\n"
		"Note\n"
		"----\n"
		"In case you want to use the filled DP matrices for any subsequent post-processing step, or you\n"
		"require other conditions than specified by the default model details, use\n"
		"RNA.fold_compound.mfe_window(), and the\n"
		"data structure RNA.fold_compound() instead.  \n"
		"\n"
		""},
	 { "Lfold", (PyCFunction)(void(*)(void))_wrap_Lfold, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Local MFE prediction using a sliding window approach (simplified interface).  \n"
		"\n"
		"This simplified interface to RNA.fold_compound.mfe_window() computes the MFE and locally optimal secondary\n"
		"structure using default options. Structures are predicted using a sliding window approach, where\n"
		"base pairs may not span outside the window. Memory required for dynamic programming (DP) matrices\n"
		"will be allocated and free'd on-the-fly. Hence, after return of this function, the recursively\n"
		"filled matrices are not available any more for any post-processing.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `Lfold()` in the global namespace. The\n"
		"    parameter `file` defaults to `NULL` and may be omitted. See e.g.   :py:func:`RNA.Lfold()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    The nucleic acid sequence  \n"
		"window_size : int\n"
		"    The window size for locally optimal structures  \n"
		"file : FILE *\n"
		"    The output file handle where predictions are written to (if NULL, output is written to stdout)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.mfe_window(), RNA.Lfoldz(), RNA.fold_compound.mfe_window_zscore()  \n"
		"\n"
		"Note\n"
		"----\n"
		"In case you want to use the filled DP matrices for any subsequent post-processing step, or you\n"
		"require other conditions than specified by the default model details, use\n"
		"RNA.fold_compound.mfe_window(), and the\n"
		"data structure RNA.fold_compound() instead.  \n"
		"\n"
		""},
	 { "aliLfold", (PyCFunction)(void(*)(void))_wrap_aliLfold, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `aliLfold()` in the global namespace. The\n"
		"    parameter `fp` defaults to `NULL` and may be omitted. See e.g.   :py:func:`RNA.aliLfold()` in\n"
		"    the :doc:`/api_python`.  \n"
		"\n"
		""},
	 { "backtrack_GQuad_IntLoop_L", (PyCFunction)(void(*)(void))_wrap_backtrack_GQuad_IntLoop_L, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"backtrack an internal loop like enclosed g-quadruplex with closing pair (i,j) with underlying Lfold\n"
		"matrix  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"c : int\n"
		"    The total contribution the loop should resemble  \n"
		"i : int\n"
		"    position i of enclosing pair  \n"
		"j : int\n"
		"    position j of enclosing pair  \n"
		"type : int\n"
		"    base pair type of enclosing pair (must be reverse type)  \n"
		"S : short *\n"
		"    integer encoded sequence  \n"
		"ggg : int **\n"
		"    triangular matrix containing g-quadruplex contributions  \n"
		"p : int *\n"
		"    here the 5' position of the gquad is stored  \n"
		"q : int *\n"
		"    here the 3' position of the gquad is stored  \n"
		"P : RNA.param() *\n"
		"    the datastructure containing the precalculated contibutions  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on success, 0 if no gquad found  \n"
		"\n"
		""},
	 { "backtrack_GQuad_IntLoop_L_comparative", (PyCFunction)(void(*)(void))_wrap_backtrack_GQuad_IntLoop_L_comparative, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "pf_fold", _wrap_pf_fold, METH_VARARGS, NULL},
	 { "pf_circ_fold", _wrap_pf_circ_fold, METH_VARARGS, NULL},
	 { "pf_add", (PyCFunction)(void(*)(void))_wrap_pf_add, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "pf_float_precision", _wrap_pf_float_precision, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Find out whether partition function computations are using single precision floating points.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 if single precision is used, 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"FLT_OR_DBL  \n"
		"\n"
		""},
	 { "pbacktrack", (PyCFunction)(void(*)(void))_wrap_pbacktrack, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Sample a secondary structure from the Boltzmann ensemble according its probability.  \n"
		"\n"
		"**Precondition**\n"
		"    st_back has to be set to 1 before calling pf_fold() or pf_fold_par()  pf_fold_par() or pf_fold()\n"
		"    have to be called first to fill the partition function matrices  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : char *\n"
		"    The RNA sequence  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A sampled secondary structure in dot-bracket notation  \n"
		"\n"
		""},
	 { "pbacktrack5", (PyCFunction)(void(*)(void))_wrap_pbacktrack5, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Sample a sub-structure from the Boltzmann ensemble according its probability.  \n"
		"\n"
		""},
	 { "pbacktrack_circ", (PyCFunction)(void(*)(void))_wrap_pbacktrack_circ, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Sample a secondary structure of a circular RNA from the Boltzmann ensemble according its\n"
		"probability.  \n"
		"\n"
		"This function does the same as pbacktrack() but assumes the RNA molecule to be circular  \n"
		"\n"
		"**Precondition**\n"
		"    st_back has to be set to 1 before calling pf_fold() or pf_fold_par()  pf_fold_par() or\n"
		"    pf_circ_fold() have to be called first to fill the partition function matrices  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.pbacktrack() instead.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : char *\n"
		"    The RNA sequence  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A sampled secondary structure in dot-bracket notation  \n"
		"\n"
		""},
	 { "free_pf_arrays", _wrap_free_pf_arrays, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Free arrays for the partition function recursions.  \n"
		"\n"
		"Call this function if you want to free all allocated memory associated with the partition function\n"
		"forward recursion.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    See RNA.fold_compound() and its related functions for how to free memory occupied by the\n"
		"    dynamic programming matrices  \n"
		"\n"
		"Note\n"
		"----\n"
		"Successive calls of pf_fold(), pf_circ_fold() already check if they should free any memory from a\n"
		"previous run.  **OpenMP notice:**  \n"
		" This function should be called before leaving a thread in order to avoid leaking memory  \n"
		"\n"
		"**Postcondition**\n"
		"    All memory allocated by pf_fold_par(), pf_fold() or pf_circ_fold() will be free'd  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"pf_fold_par(), pf_fold(), pf_circ_fold()  \n"
		"\n"
		""},
	 { "update_pf_params", (PyCFunction)(void(*)(void))_wrap_update_pf_params, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Recalculate energy parameters.  \n"
		"\n"
		"Call this function to recalculate the pair matrix and energy parameters after a change in folding\n"
		"parameters like temperature  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.exp_params_subst() instead  \n"
		"\n"
		""},
	 { "mean_bp_distance", (PyCFunction)(void(*)(void))_wrap_mean_bp_distance, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get the mean base pair distance of the last partition function computation.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.mean_bp_distance() or RNA.mean_bp_distance_pr() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"length : int\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double  \n"
		"    mean base pair distance in thermodynamic ensemble  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.mean_bp_distance(), RNA.mean_bp_distance_pr()  \n"
		"\n"
		""},
	 { "init_pf_fold", (PyCFunction)(void(*)(void))_wrap_init_pf_fold, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Allocate space for pf_fold().  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is obsolete and will be removed soon!  \n"
		"\n"
		""},
	 { "init_pf_circ_fold", (PyCFunction)(void(*)(void))_wrap_init_pf_circ_fold, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "centroid", (PyCFunction)(void(*)(void))_wrap_centroid, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is deprecated and should not be used anymore as it is not threadsafe!  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"get_centroid_struct_pl(), get_centroid_struct_pr()  \n"
		"\n"
		""},
	 { "co_pf_fold", _wrap_co_pf_fold, METH_VARARGS, NULL},
	 { "free_co_pf_arrays", _wrap_free_co_pf_arrays, METH_NOARGS, "\n"
		"\n"
		"\n"
		"Free the memory occupied by co_pf_fold().  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function will be removed for the new API soon! See RNA.fold_compound.pf_dimer(),\n"
		"    RNA.fold_compound(),\n"
		"    and RNA.fold_compound_free() for an alternative  \n"
		"\n"
		""},
	 { "update_co_pf_params", (PyCFunction)(void(*)(void))_wrap_update_co_pf_params, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Recalculate energy parameters.  \n"
		"\n"
		"This function recalculates all energy parameters given the current model settings.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.fold_compound.exp_params_subst() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"length : int\n"
		"    Length of the current RNA sequence  \n"
		"\n"
		""},
	 { "get_gquad_pattern_pf", (PyCFunction)(void(*)(void))_wrap_get_gquad_pattern_pf, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "get_plist_gquad_from_pr", (PyCFunction)(void(*)(void))_wrap_get_plist_gquad_from_pr, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "get_plist_gquad_from_pr_max", (PyCFunction)(void(*)(void))_wrap_get_plist_gquad_from_pr_max, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "get_gquad_pf_matrix", (PyCFunction)(void(*)(void))_wrap_get_gquad_pf_matrix, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "get_gquad_pf_matrix_comparative", (PyCFunction)(void(*)(void))_wrap_get_gquad_pf_matrix_comparative, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "get_pr", (PyCFunction)(void(*)(void))_wrap_get_pr, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "get_centroid_struct_pl", (PyCFunction)(void(*)(void))_wrap_get_centroid_struct_pl, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get the centroid structure of the ensemble.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function was renamed to RNA.centroid_from_plist()  \n"
		"\n"
		""},
	 { "get_centroid_struct_pr", (PyCFunction)(void(*)(void))_wrap_get_centroid_struct_pr, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get the centroid structure of the ensemble.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function was renamed to RNA.centroid_from_probs()  \n"
		"\n"
		""},
	 { "MEA_from_plist", _wrap_MEA_from_plist, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compute a MEA (maximum expected accuracy) structure from a list of probabilities.  \n"
		"\n"
		"The algorithm maximizes the expected accuracy  \n"
		"\n"
		".. math::\n"
		"\n"
		"  A(S) = \\sum_{(i,j) \\in S} 2 \\gamma p_{ij} + \\sum_{i \\notin S} p^u_{i}  \n"
		"\n"
		"Higher values of :math:`\\gamma` result in more base pairs of lower probability and thus higher\n"
		"sensitivity. Low values of :math:`\\gamma` result in structures containing only highly likely pairs\n"
		"(high specificity). The code of the MEA function also demonstrates the use of sparse dynamic\n"
		"programming scheme to reduce the time and memory complexity of folding.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `MEA_from_plist`(gamma = 1., md = NULL). Note,\n"
		"    that it returns the MEA structure and MEA value as a tuple (MEA_structure, MEA). See, e.g.\n"
		"    :py:func:`RNA.MEA_from_plist()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"plist : RNA.ep() *\n"
		"    A list of base pair probabilities the MEA structure is computed from  \n"
		"sequence : const char *\n"
		"    The RNA sequence that corresponds to the list of probability values  \n"
		"gamma : double\n"
		"    The weighting factor for base pairs vs. unpaired nucleotides  \n"
		"md : RNA.md() *\n"
		"    A model details data structure (maybe NULL)  \n"
		"mea : float *\n"
		"    A pointer to a variable where the MEA value will be written to  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    An MEA structure (or NULL on any error)  \n"
		"\n"
		"Note\n"
		"----\n"
		"The unpaired probabilities :math:`p^u_{i} = 1 - \\sum_{j \\neq i} p_{ij}` are usually computed from\n"
		"the supplied pairing probabilities :math:`p_{ij}` as stored in `plist` entries of type\n"
		"RNA.PLIST_TYPE_BASEPAIR. To overwrite individual :math:`p^u_{o}` values simply add entries with\n"
		"type RNA.PLIST_TYPE_UNPAIRED  \n"
		" To include G-Quadruplex support, the corresponding field in `md` must be set.  \n"
		"\n"
		""},
	 { "new_pbacktrack_mem", _wrap_new_pbacktrack_mem, METH_NOARGS, NULL},
	 { "delete_pbacktrack_mem", _wrap_delete_pbacktrack_mem, METH_O, NULL},
	 { "pbacktrack_mem_swigregister", pbacktrack_mem_swigregister, METH_O, NULL},
	 { "pbacktrack_mem_swiginit", pbacktrack_mem_swiginit, METH_VARARGS, NULL},
	 { "pfl_fold", (PyCFunction)(void(*)(void))_wrap_pfl_fold, METH_VARARGS|METH_KEYWORDS, "\n"
		"pfl_fold(std::string sequence, int w, int L, double cutoff) -> ElemProbVector\n"
		"\n"
		"\n"
		"Compute base pair probabilities using a sliding-window approach.  \n"
		"\n"
		"This is a simplified wrapper to RNA.fold_compound.probs_window() that given a nucleid acid sequence, a window\n"
		"size, a maximum base pair span, and a cutoff value computes the pair probabilities for any base pair\n"
		"in any window. The pair probabilities are returned as a list and the user has to take care to free()\n"
		"the memory occupied by the list.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : const char *\n"
		"    The nucleic acid input sequence  \n"
		"window_size : int\n"
		"    The size of the sliding window  \n"
		"max_bp_span : int\n"
		"    The maximum distance along the backbone between two nucleotides that form a base pairs  \n"
		"cutoff : float\n"
		"    A cutoff value that omits all pairs with lower probability  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.ep() *  \n"
		"    A list of base pair probabilities, terminated by an entry with RNA.ep().i and RNA.ep().j set\n"
		"    to 0  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.probs_window(), RNA.pfl_fold_cb(), RNA.pfl_fold_up()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function uses default model settings! For custom model settings, we refer to the function\n"
		"RNA.fold_compound.probs_window().  \n"
		" In case of any computation errors, this function returns `NULL`  \n"
		"\n"
		""},
	 { "pfl_fold_up", (PyCFunction)(void(*)(void))_wrap_pfl_fold_up, METH_VARARGS|METH_KEYWORDS, "\n"
		"pfl_fold_up(std::string sequence, int ulength, int window_size, int max_bp_span) -> DoubleDoubleVector\n"
		"\n"
		"\n"
		"Compute probability of contiguous unpaired segments.  \n"
		"\n"
		"This is a simplified wrapper to RNA.fold_compound.probs_window() that given a nucleic acid sequence, a maximum\n"
		"length of unpaired segments (`ulength`), a window size, and a maximum base pair span computes the\n"
		"equilibrium probability of any segment not exceeding `ulength`. The probabilities to be unpaired are\n"
		"returned as a 1-based, 2-dimensional matrix with dimensions :math:`N \\times M`, where :math:`N` is\n"
		"the length of the sequence and :math:`M` is the maximum segment length. As an example, the\n"
		"probability of a segment of size 5 starting at position 100 is stored in the matrix entry\n"
		":math:`X[100][5]`.  \n"
		"\n"
		"It is the users responsibility to free the memory occupied by this matrix.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : const char *\n"
		"    The nucleic acid input sequence  \n"
		"ulength : int\n"
		"    The maximal length of an unpaired segment  \n"
		"window_size : int\n"
		"    The size of the sliding window  \n"
		"max_bp_span : int\n"
		"    The maximum distance along the backbone between two nucleotides that form a base pairs  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"double **  \n"
		"    The probabilities to be unpaired for any segment not exceeding `ulength`  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function uses default model settings! For custom model settings, we refer to the function\n"
		"RNA.fold_compound.probs_window().  \n"
		"\n"
		""},
	 { "SOLUTION_energy_set", _wrap_SOLUTION_energy_set, METH_VARARGS, NULL},
	 { "SOLUTION_energy_get", _wrap_SOLUTION_energy_get, METH_O, NULL},
	 { "SOLUTION_structure_set", _wrap_SOLUTION_structure_set, METH_VARARGS, NULL},
	 { "SOLUTION_structure_get", _wrap_SOLUTION_structure_get, METH_O, NULL},
	 { "SOLUTION_get", (PyCFunction)(void(*)(void))_wrap_SOLUTION_get, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SOLUTION_size", _wrap_SOLUTION_size, METH_O, NULL},
	 { "delete_SOLUTION", _wrap_delete_SOLUTION, METH_O, NULL},
	 { "new_SOLUTION", _wrap_new_SOLUTION, METH_NOARGS, NULL},
	 { "SOLUTION_swigregister", SOLUTION_swigregister, METH_O, NULL},
	 { "SOLUTION_swiginit", SOLUTION_swiginit, METH_VARARGS, NULL},
	 { "subopt_solution_energy_set", _wrap_subopt_solution_energy_set, METH_VARARGS, NULL},
	 { "subopt_solution_energy_get", _wrap_subopt_solution_energy_get, METH_O, NULL},
	 { "subopt_solution_structure_set", _wrap_subopt_solution_structure_set, METH_VARARGS, NULL},
	 { "subopt_solution_structure_get", _wrap_subopt_solution_structure_get, METH_O, NULL},
	 { "subopt_solution___str__", _wrap_subopt_solution___str__, METH_O, NULL},
	 { "new_subopt_solution", _wrap_new_subopt_solution, METH_NOARGS, NULL},
	 { "delete_subopt_solution", _wrap_delete_subopt_solution, METH_O, NULL},
	 { "subopt_solution_swigregister", subopt_solution_swigregister, METH_O, NULL},
	 { "subopt_solution_swiginit", subopt_solution_swiginit, METH_VARARGS, NULL},
	 { "SuboptVector_iterator", _wrap_SuboptVector_iterator, METH_O, NULL},
	 { "SuboptVector___nonzero__", _wrap_SuboptVector___nonzero__, METH_O, NULL},
	 { "SuboptVector___bool__", _wrap_SuboptVector___bool__, METH_O, NULL},
	 { "SuboptVector___len__", _wrap_SuboptVector___len__, METH_O, NULL},
	 { "SuboptVector___getslice__", (PyCFunction)(void(*)(void))_wrap_SuboptVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SuboptVector___setslice__", _wrap_SuboptVector___setslice__, METH_VARARGS, NULL},
	 { "SuboptVector___delslice__", (PyCFunction)(void(*)(void))_wrap_SuboptVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SuboptVector___delitem__", _wrap_SuboptVector___delitem__, METH_VARARGS, NULL},
	 { "SuboptVector___getitem__", _wrap_SuboptVector___getitem__, METH_VARARGS, NULL},
	 { "SuboptVector___setitem__", _wrap_SuboptVector___setitem__, METH_VARARGS, NULL},
	 { "SuboptVector_pop", _wrap_SuboptVector_pop, METH_O, NULL},
	 { "SuboptVector_append", (PyCFunction)(void(*)(void))_wrap_SuboptVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SuboptVector_empty", _wrap_SuboptVector_empty, METH_O, NULL},
	 { "SuboptVector_size", _wrap_SuboptVector_size, METH_O, NULL},
	 { "SuboptVector_swap", (PyCFunction)(void(*)(void))_wrap_SuboptVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SuboptVector_begin", _wrap_SuboptVector_begin, METH_O, NULL},
	 { "SuboptVector_end", _wrap_SuboptVector_end, METH_O, NULL},
	 { "SuboptVector_rbegin", _wrap_SuboptVector_rbegin, METH_O, NULL},
	 { "SuboptVector_rend", _wrap_SuboptVector_rend, METH_O, NULL},
	 { "SuboptVector_clear", _wrap_SuboptVector_clear, METH_O, NULL},
	 { "SuboptVector_get_allocator", _wrap_SuboptVector_get_allocator, METH_O, NULL},
	 { "SuboptVector_pop_back", _wrap_SuboptVector_pop_back, METH_O, NULL},
	 { "SuboptVector_erase", _wrap_SuboptVector_erase, METH_VARARGS, NULL},
	 { "new_SuboptVector", _wrap_new_SuboptVector, METH_VARARGS, NULL},
	 { "SuboptVector_push_back", (PyCFunction)(void(*)(void))_wrap_SuboptVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SuboptVector_front", _wrap_SuboptVector_front, METH_O, NULL},
	 { "SuboptVector_back", _wrap_SuboptVector_back, METH_O, NULL},
	 { "SuboptVector_assign", (PyCFunction)(void(*)(void))_wrap_SuboptVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SuboptVector_resize", _wrap_SuboptVector_resize, METH_VARARGS, NULL},
	 { "SuboptVector_insert", _wrap_SuboptVector_insert, METH_VARARGS, NULL},
	 { "SuboptVector_reserve", (PyCFunction)(void(*)(void))_wrap_SuboptVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "SuboptVector_capacity", _wrap_SuboptVector_capacity, METH_O, NULL},
	 { "delete_SuboptVector", _wrap_delete_SuboptVector, METH_O, NULL},
	 { "SuboptVector_swigregister", SuboptVector_swigregister, METH_O, NULL},
	 { "SuboptVector_swiginit", SuboptVector_swiginit, METH_VARARGS, NULL},
	 { "subopt", _wrap_subopt, METH_VARARGS, NULL},
	 { "zukersubopt", (PyCFunction)(void(*)(void))_wrap_zukersubopt, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute Zuker type suboptimal structures.  \n"
		"\n"
		"Compute Suboptimal structures according to M. Zuker, i.e. for every possible base pair the minimum\n"
		"energy structure containing the resp. base pair. Returns a list of these structures and their\n"
		"energies.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    use RNA.zukersubopt() instead  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    RNA sequence  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"SOLUTION *  \n"
		"    List of zuker suboptimal structures  \n"
		"\n"
		""},
	 { "inverse_fold", (PyCFunction)(void(*)(void))_wrap_inverse_fold, METH_VARARGS|METH_KEYWORDS, "\n"
		"inverse_fold(char * start, char const * target) -> char *\n"
		"\n"
		"\n"
		"Find sequences with predefined structure.  \n"
		"\n"
		"This function searches for a sequence with minimum free energy structure provided in the parameter\n"
		"'target', starting with sequence 'start'. It returns 0 if the search was successful, otherwise a\n"
		"structure distance in terms of the energy difference between the search result and the actual target\n"
		"'target' is returned. The found sequence is returned in 'start'. If give_up is set to 1, the\n"
		"function will return as soon as it is clear that the search will be unsuccessful, this speeds up the\n"
		"algorithm if you are only interested in exact solutions.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"start : char *\n"
		"    The start sequence  \n"
		"target : const char *\n"
		"    The target secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The distance to the target in case a search was unsuccessful, 0 otherwise  \n"
		"\n"
		""},
	 { "inverse_pf_fold", (PyCFunction)(void(*)(void))_wrap_inverse_pf_fold, METH_VARARGS|METH_KEYWORDS, "\n"
		"inverse_pf_fold(char * start, char const * target) -> char *\n"
		"\n"
		"\n"
		"Find sequence that maximizes probability of a predefined structure.  \n"
		"\n"
		"This function searches for a sequence with maximum probability to fold into the provided structure\n"
		"'target' using the partition function algorithm. It returns :math:`-kT \\cdot \\log(p)` where\n"
		":math:`p` is the frequency of 'target' in the ensemble of possible structures. This is usually much\n"
		"slower than inverse_fold().  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"start : char *\n"
		"    The start sequence  \n"
		"target : const char *\n"
		"    The target secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The distance to the target in case a search was unsuccessful, 0 otherwise  \n"
		"\n"
		""},
	 { "b2HIT", (PyCFunction)(void(*)(void))_wrap_b2HIT, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Converts the full structure from bracket notation to the HIT notation including root.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    See RNA.db_to_tree_string() and RNA.STRUCTURE_TREE_HIT for a replacement  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "b2C", (PyCFunction)(void(*)(void))_wrap_b2C, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Converts the full structure from bracket notation to the a coarse grained notation using the 'H' 'B'\n"
		"'I' 'M' and 'R' identifiers.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    See RNA.db_to_tree_string() and RNA.STRUCTURE_TREE_SHAPIRO_SHORT for a replacement  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "b2Shapiro", (PyCFunction)(void(*)(void))_wrap_b2Shapiro, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Converts the full structure from bracket notation to the *weighted* coarse grained notation using\n"
		"the 'H' 'B' 'I' 'M' 'S' 'E' and 'R' identifiers.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    See RNA.db_to_tree_string() and RNA.STRUCTURE_TREE_SHAPIRO_WEIGHT for a replacement  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "add_root", (PyCFunction)(void(*)(void))_wrap_add_root, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Adds a root to an un-rooted tree in any except bracket notation.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "expand_Shapiro", (PyCFunction)(void(*)(void))_wrap_expand_Shapiro, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Inserts missing 'S' identifiers in unweighted coarse grained structures as obtained from b2C().  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"coarse : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "expand_Full", (PyCFunction)(void(*)(void))_wrap_expand_Full, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Convert the full structure from bracket notation to the expanded notation including root.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "unexpand_Full", (PyCFunction)(void(*)(void))_wrap_unexpand_Full, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Restores the bracket notation from an expanded full or HIT tree, that is any tree using only\n"
		"identifiers 'U' 'P' and 'R'.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ffull : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "unweight", (PyCFunction)(void(*)(void))_wrap_unweight, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Strip weights from any weighted tree.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"wcoarse : const char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"\n"
		""},
	 { "unexpand_aligned_F", (PyCFunction)(void(*)(void))_wrap_unexpand_aligned_F, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Converts two aligned structures in expanded notation.  \n"
		"\n"
		"Takes two aligned structures as produced by tree_edit_distance() function back to bracket notation\n"
		"with '_' as the gap character. The result overwrites the input.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"align : char *  \n"
		"\n"
		""},
	 { "parse_structure", (PyCFunction)(void(*)(void))_wrap_parse_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Collects a statistic of structure elements of the full structure in bracket notation.  \n"
		"\n"
		"The function writes to the following global variables: loop_size, loop_degree, helix_size, loops,\n"
		"pairs, unpaired  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *  \n"
		"\n"
		""},
	 { "make_tree", (PyCFunction)(void(*)(void))_wrap_make_tree, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Constructs a Tree ( essentially the postorder list ) of the structure 'struc', for use in\n"
		"tree_edit_distance().  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"struc : char *\n"
		"    may be any rooted structure representation.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"Tree *  \n"
		"\n"
		""},
	 { "tree_edit_distance", (PyCFunction)(void(*)(void))_wrap_tree_edit_distance, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculates the edit distance of the two trees.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"T1 : Tree *\n"
		"T2 : Tree *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"\n"
		""},
	 { "print_tree", (PyCFunction)(void(*)(void))_wrap_print_tree, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Print a tree (mainly for debugging).  \n"
		"\n"
		""},
	 { "free_tree", (PyCFunction)(void(*)(void))_wrap_free_tree, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Free the memory allocated for Tree t.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"t : Tree *  \n"
		"\n"
		""},
	 { "Make_swString", (PyCFunction)(void(*)(void))_wrap_Make_swString, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Convert a structure into a format suitable for string_edit_distance().  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : char *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"swString *  \n"
		"\n"
		""},
	 { "string_edit_distance", (PyCFunction)(void(*)(void))_wrap_string_edit_distance, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the string edit distance of T1 and T2.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"T1 : swString *\n"
		"T2 : swString *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"\n"
		""},
	 { "profile_edit_distance", (PyCFunction)(void(*)(void))_wrap_profile_edit_distance, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Align the 2 probability profiles T1, T2  \n"
		".  \n"
		"\n"
		"This is like a Needleman-Wunsch alignment, we should really use affine gap-costs ala Gotoh  \n"
		"\n"
		""},
	 { "Make_bp_profile_bppm", (PyCFunction)(void(*)(void))_wrap_Make_bp_profile_bppm, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"condense pair probability matrix into a vector containing probabilities for unpaired, upstream\n"
		"paired and downstream paired.  \n"
		"\n"
		"This resulting probability profile is used as input for profile_edit_distance  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"bppm : FLT_OR_DBL *\n"
		"    A pointer to the base pair probability matrix  \n"
		"length : int\n"
		"    The length of the sequence  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float *  \n"
		"    The bp profile  \n"
		"\n"
		""},
	 { "print_bppm", (PyCFunction)(void(*)(void))_wrap_print_bppm, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"print string representation of probability profile  \n"
		"\n"
		""},
	 { "free_profile", (PyCFunction)(void(*)(void))_wrap_free_profile, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"free space allocated in Make_bp_profile  \n"
		"\n"
		"Backward compatibility only. You can just use plain free()  \n"
		"\n"
		""},
	 { "Make_bp_profile", (PyCFunction)(void(*)(void))_wrap_Make_bp_profile, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is deprecated and will be removed soon! See Make_bp_profile_bppm() for a\n"
		"    replacement  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"Make_bp_profile_bppm()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is NOT threadsafe  \n"
		"\n"
		""},
	 { "deref_any", (PyCFunction)(void(*)(void))_wrap_deref_any, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "get_aligned_line", (PyCFunction)(void(*)(void))_wrap_get_aligned_line, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "file_SHAPE_read", (PyCFunction)(void(*)(void))_wrap_file_SHAPE_read, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Read data from a given SHAPE reactivity input file.  \n"
		"\n"
		"This function parses the informations from a given file and stores the result in the preallocated\n"
		"string sequence and the double array values.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"file_name : const char *\n"
		"    Path to the constraints file  \n"
		"length : int\n"
		"    Length of the sequence (file entries exceeding this limit will cause an error)  \n"
		"default_value : double\n"
		"    Value for missing indices  \n"
		"sequence : char *\n"
		"    Pointer to an array used for storing the sequence obtained from the SHAPE reactivity file  \n"
		"values : double *\n"
		"    Pointer to an array used for storing the values obtained from the SHAPE reactivity file  \n"
		"\n"
		""},
	 { "file_fasta_read", (PyCFunction)(void(*)(void))_wrap_file_fasta_read, METH_VARARGS|METH_KEYWORDS, "\n"
		"file_fasta_read(FILE * file, unsigned int options=0) -> int\n"
		"\n"
		"\n"
		"Get a (fasta) data set from a file or stdin.  \n"
		"\n"
		"This function may be used to obtain complete datasets from a filehandle or stdin. A dataset is\n"
		"always defined to contain at least a sequence. If data starts with a fasta header, i.e. a line like  \n"
		"\n"
		"    >some header info  then RNA.file_fasta_read_record() will assume that the sequence that follows\n"
		"    the header may span over several lines. To disable this behavior and to assign a single line to\n"
		"    the argument 'sequence' one can pass RNA.INPUT_NO_SPAN in the 'options' argument. If no fasta\n"
		"    header is read in the beginning of a data block, a sequence must not span over multiple lines!  \n"
		"\n"
		"Unless the options RNA.INPUT_NOSKIP_COMMENTS or RNA.INPUT_NOSKIP_BLANK_LINES are passed, a\n"
		"sequence may be interrupted by lines starting with a comment character or empty lines.  \n"
		" A sequence is regarded as completely read if it was either assumed to not span over multiple lines,\n"
		" a secondary structure or structure constraint follows the sequence on the next line, or a new\n"
		" header marks the beginning of a new sequence...  \n"
		"\n"
		"All lines following the sequence (this includes comments) that do not initiate a new dataset\n"
		"according to the above definition are available through the line-array 'rest'. Here one can usually\n"
		"find the structure constraint or other information belonging to the current dataset. Filling of\n"
		"'rest' may be prevented by passing RNA.INPUT_NO_REST to the options argument.  \n"
		"\n"
		"The main purpose of this function is to be able to easily parse blocks of data in the header of a\n"
		"loop where all calculations for the appropriate data is done inside the loop. The loop may be then\n"
		"left on certain return values, e.g.:  \n"
		"\n"
		"\n"
		"In the example above, the while loop will be terminated when RNA.file_fasta_read_record() returns\n"
		"either an error, EOF, or a user initiated quit request.  \n"
		"\n"
		"As long as data is read from stdin (we are passing NULL as the file pointer), the id is printed if\n"
		"it is available for the current block of data. The sequence will be printed in any case and if some\n"
		"more lines belong to the current block of data each line will be printed as well.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"header : char **\n"
		"    A pointer which will be set such that it points to the header of the record  \n"
		"sequence : char **\n"
		"    A pointer which will be set such that it points to the sequence of the record  \n"
		"rest : char ***\n"
		"    A pointer which will be set such that it points to an array of lines which also belong to the\n"
		"    record  \n"
		"file : FILE *\n"
		"    A file handle to read from (if NULL, this function reads from stdin)  \n"
		"options : unsigned int\n"
		"    Some options which may be passed to alter the behavior of the function, use 0 for no options  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int  \n"
		"    A flag with information about what the function actually did read  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function will exit any program with an error message if no sequence could be read!  \n"
		" This function is NOT threadsafe! It uses a global variable to store information about the next data\n"
		" block. Do not forget to free the memory occupied by header, sequence and rest!  \n"
		"\n"
		""},
	 { "file_RNAstrand_db_read_record", (PyCFunction)(void(*)(void))_wrap_file_RNAstrand_db_read_record, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "file_connect_read_record", (PyCFunction)(void(*)(void))_wrap_file_connect_read_record, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "extract_record_rest_structure", (PyCFunction)(void(*)(void))_wrap_extract_record_rest_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "read_record", (PyCFunction)(void(*)(void))_wrap_read_record, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Get a data record from stdin.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is deprecated! Use RNA.file_fasta_read_record() as a replacment.  \n"
		"\n"
		""},
	 { "get_multi_input_line", (PyCFunction)(void(*)(void))_wrap_get_multi_input_line, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "file_msa_detect_format", (PyCFunction)(void(*)(void))_wrap_file_msa_detect_format, METH_VARARGS|METH_KEYWORDS, "\n"
		"file_msa_detect_format(std::string filename, unsigned int options=) -> unsigned int\n"
		"\n"
		"\n"
		"Detect the format of a multiple sequence alignment file.  \n"
		"\n"
		"This function attempts to determine the format of a file that supposedly contains a multiple\n"
		"sequence alignment (MSA). This is useful in cases where a MSA file contains more than a single\n"
		"record and therefore RNA.file_msa_read() can not be applied, since it only retrieves the first.\n"
		"Here, one can try to guess the correct file format using this function and then loop over the file,\n"
		"record by record using one of the low-level record retrieval functions for the corresponding MSA\n"
		"file format.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function exists as an overloaded version where the `options` parameter may be omitted! In\n"
		"    that case, the `options` parameter defaults to RNA.FILE_FORMAT_MSA_DEFAULT. See, e.g.\n"
		"    :py:func:`RNA.file_msa_detect_format()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : const char *\n"
		"    The name of input file that contains the alignment  \n"
		"options : unsigned int\n"
		"    Options to manipulate the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int  \n"
		"    The MSA file format, or RNA.FILE_FORMAT_MSA_UNKNOWN  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.file_msa_read(), RNA.file_stockholm_read_record(), RNA.file_clustal_read_record(),\n"
		"RNA.file_fasta_read_record()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function parses the entire first record within the specified file. As a result, it returns\n"
		"RNA.FILE_FORMAT_MSA_UNKNOWN not only if it can't detect the file's format, but also in cases where\n"
		"the file doesn't contain sequences!  \n"
		"\n"
		""},
	 { "file_msa_write", (PyCFunction)(void(*)(void))_wrap_file_msa_write, METH_VARARGS|METH_KEYWORDS, "\n"
		"file_msa_write(std::string filename, StringVector names, StringVector alignment, std::string id=\"\", std::string structure=\"\", std::string source=\"\", unsigned int options=VRNA_FILE_FORMAT_MSA_STOCKHOLM|VRNA_FILE_FORMAT_MSA_APPEND) -> int\n"
		"\n"
		"\n"
		"Write multiple sequence alignment file.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    In the target scripting language, this function exists as a set of overloaded versions, where\n"
		"    the last four parameters may be omitted. If the `options` parameter is missing the options\n"
		"    default to (RNA.FILE_FORMAT_MSA_STOCKHOLM | RNA.FILE_FORMAT_MSA_APPEND). See, e.g.\n"
		"    :py:func:`RNA.file_msa_write()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : const char *\n"
		"    The output filename  \n"
		"names : const char **\n"
		"    The array of sequence names / identifies  \n"
		"aln : const char **\n"
		"    The array of aligned sequences  \n"
		"id : const char *\n"
		"    An optional ID for the alignment  \n"
		"structure : const char *\n"
		"    An optional consensus structure  \n"
		"source : const char *\n"
		"    A string describing the source of the alignment  \n"
		"options : unsigned int\n"
		"    Options to manipulate the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-null upon successfully writing the alignment to file  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.FILE_FORMAT_MSA_STOCKHOLM, RNA.FILE_FORMAT_MSA_APPEND, RNA.FILE_FORMAT_MSA_MIS  \n"
		"\n"
		"Note\n"
		"----\n"
		"Currently, we only support msa-formats-stockholm output  \n"
		"\n"
		""},
	 { "file_msa_read", (PyCFunction)(void(*)(void))_wrap_file_msa_read, METH_VARARGS|METH_KEYWORDS, "\n"
		"file_msa_read(std::string filename, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Read a multiple sequence alignment from file.  \n"
		"\n"
		"This function reads the (first) multiple sequence alignment from an input file. The read alignment\n"
		"is split into the sequence id/name part and the actual sequence information and stored in memory as\n"
		"arrays of ids/names and sequences. If the alignment file format allows for additional information,\n"
		"such as an ID of the entire alignment or consensus structure information, this data is retrieved as\n"
		"well and made available. The `options` parameter allows to specify the set of alignment file formats\n"
		"that should be used to retrieve the data. If 0 is passed as option, the list of alignment file\n"
		"formats defaults to RNA.FILE_FORMAT_MSA_DEFAULT.  \n"
		"\n"
		"Currently, the list of parsable multiple sequence alignment file formats consists of:  \n"
		"\n"
		"*   msa-formats-clustal  \n"
		"*   msa-formats-stockholm  \n"
		"*   msa-formats-fasta  \n"
		"*   msa-formats-maf  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    In the target scripting language, only the first and last argument, `filename` and `options`,\n"
		"    are passed to the corresponding function. The other arguments, which serve as output in the\n"
		"    C-library, are available as additional return values. This function exists as an overloaded\n"
		"    version where the `options` parameter may be omitted! In that case, the `options` parameter\n"
		"    defaults to RNA.FILE_FORMAT_MSA_STOCKHOLM. See, e.g.    :py:func:`RNA.file_msa_read()` in the\n"
		"    :doc:`/api_python`  and    :ref:`examples/python:parsing alignments`  in the Python examples.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : const char *\n"
		"    The name of input file that contains the alignment  \n"
		"names : char ***\n"
		"    An address to the pointer where sequence identifiers should be written to  \n"
		"aln : char ***\n"
		"    An address to the pointer where aligned sequences should be written to  \n"
		"id : char **\n"
		"    An address to the pointer where the alignment ID should be written to (Maybe NULL)  \n"
		"structure : char **\n"
		"    An address to the pointer where consensus structure information should be written to (Maybe\n"
		"    NULL)  \n"
		"options : unsigned int\n"
		"    Options to manipulate the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The number of sequences in the alignment, or -1 if no alignment record could be found  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.file_msa_read_record(), RNA.FILE_FORMAT_MSA_CLUSTAL, RNA.FILE_FORMAT_MSA_STOCKHOLM,\n"
		"RNA.FILE_FORMAT_MSA_FASTA, RNA.FILE_FORMAT_MSA_MAF, RNA.FILE_FORMAT_MSA_DEFAULT,\n"
		"RNA.FILE_FORMAT_MSA_NOCHECK  \n"
		"\n"
		"Note\n"
		"----\n"
		"After successfully reading an alignment, this function performs a validation of the data that\n"
		"includes uniqueness of the sequence identifiers, and equal sequence lengths. This check can be\n"
		"deactivated by passing RNA.FILE_FORMAT_MSA_NOCHECK in the `options` parameter.  \n"
		" It is the users responsibility to free any memory occupied by the output arguments `names`, `aln`,\n"
		" `id`, and `structure` after calling this function. The function automatically sets the latter two\n"
		" arguments to `NULL` in case no corresponding data could be retrieved from the input alignment.  \n"
		"\n"
		""},
	 { "file_msa_read_record", (PyCFunction)(void(*)(void))_wrap_file_msa_read_record, METH_VARARGS|METH_KEYWORDS, "\n"
		"file_msa_read_record(FILE * filehandle, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Read a multiple sequence alignment from file handle.  \n"
		"\n"
		"Similar to RNA.file_msa_read(), this function reads a multiple sequence alignment from an input\n"
		"file handle. Since using a file handle, this function is not limited to the first alignment record,\n"
		"but allows for looping over all alignments within the input.  \n"
		"\n"
		"The read alignment is split into the sequence id/name part and the actual sequence information and\n"
		"stored in memory as arrays of ids/names and sequences. If the alignment file format allows for\n"
		"additional information, such as an ID of the entire alignment or consensus structure information,\n"
		"this data is retrieved as well and made available. The `options` parameter allows to specify the\n"
		"alignment file format used to retrieve the data. A single format must be specified here, see\n"
		"RNA.file_msa_detect_format() for helping to determine the correct MSA file format.  \n"
		"\n"
		"Currently, the list of parsable multiple sequence alignment file formats consists of:  \n"
		"\n"
		"*   msa-formats-clustal  \n"
		"*   msa-formats-stockholm  \n"
		"*   msa-formats-fasta  \n"
		"*   msa-formats-maf  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    In the target scripting language, only the first and last argument, `fp` and `options`, are\n"
		"    passed to the corresponding function. The other arguments, which serve as output in the\n"
		"    C-library, are available as additional return values. This function exists as an overloaded\n"
		"    version where the `options` parameter may be omitted! In that case, the `options` parameter\n"
		"    defaults to RNA.FILE_FORMAT_MSA_STOCKHOLM. See, e.g.    :py:func:`RNA.file_msa_read_record()`\n"
		"    in the :doc:`/api_python`  and    :ref:`examples/python:parsing alignments`  in the Python\n"
		"    examples.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"fp : FILE *\n"
		"    The file pointer the data will be retrieved from  \n"
		"names : char ***\n"
		"    An address to the pointer where sequence identifiers should be written to  \n"
		"aln : char ***\n"
		"    An address to the pointer where aligned sequences should be written to  \n"
		"id : char **\n"
		"    An address to the pointer where the alignment ID should be written to (Maybe NULL)  \n"
		"structure : char **\n"
		"    An address to the pointer where consensus structure information should be written to (Maybe\n"
		"    NULL)  \n"
		"options : unsigned int\n"
		"    Options to manipulate the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The number of sequences in the alignment, or -1 if no alignment record could be found  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.file_msa_read(), RNA.file_msa_detect_format(), RNA.FILE_FORMAT_MSA_CLUSTAL,\n"
		"RNA.FILE_FORMAT_MSA_STOCKHOLM, RNA.FILE_FORMAT_MSA_FASTA, RNA.FILE_FORMAT_MSA_MAF,\n"
		"RNA.FILE_FORMAT_MSA_DEFAULT, RNA.FILE_FORMAT_MSA_NOCHECK  \n"
		"\n"
		"Note\n"
		"----\n"
		"After successfully reading an alignment, this function performs a validation of the data that\n"
		"includes uniqueness of the sequence identifiers, and equal sequence lengths. This check can be\n"
		"deactivated by passing RNA.FILE_FORMAT_MSA_NOCHECK in the `options` parameter.  \n"
		" It is the users responsibility to free any memory occupied by the output arguments `names`, `aln`,\n"
		" `id`, and `structure` after calling this function. The function automatically sets the latter two\n"
		" arguments to `NULL` in case no corresponding data could be retrieved from the input alignment.  \n"
		"\n"
		""},
	 { "seq_encode", (PyCFunction)(void(*)(void))_wrap_seq_encode, METH_VARARGS|METH_KEYWORDS, "\n"
		"seq_encode(std::string sequence, md md_p=None) -> IntVector\n"
		"\n"
		"\n"
		"Get a numerical representation of the nucleotide sequence.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    In the target scripting language, this function is wrapped as overloaded function `seq_encode()`\n"
		"    where the last parameter, the `model_details` data structure, is optional. If it is omitted,\n"
		"    default model settings are applied, i.e. default nucleotide letter conversion. The wrapped\n"
		"    function returns a list/tuple of integer representations of the input sequence. See, e.g.\n"
		"    :py:func:`RNA.seq_encode()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : const char *\n"
		"    The input sequence in upper-case letters  \n"
		"md : RNA.md() *\n"
		"    A pointer to a RNA.md() data structure that specifies the conversion type  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"short *  \n"
		"    A list of integer encodings for each sequence letter (1-based). Position 0 denotes the length of\n"
		"    the list  \n"
		"\n"
		""},
	 { "new_cmd", _wrap_new_cmd, METH_NOARGS, NULL},
	 { "delete_cmd", _wrap_delete_cmd, METH_O, NULL},
	 { "cmd_swigregister", cmd_swigregister, METH_O, NULL},
	 { "cmd_swiginit", cmd_swiginit, METH_VARARGS, NULL},
	 { "file_commands_read", (PyCFunction)(void(*)(void))_wrap_file_commands_read, METH_VARARGS|METH_KEYWORDS, "\n"
		"file_commands_read(std::string filename, unsigned int options=) -> cmd\n"
		"\n"
		"\n"
		"Extract a list of commands from a command file.  \n"
		"\n"
		"Read a list of commands specified in the input file and return them as list of abstract commands  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as global function `file_commands_read()`. See, e.g.\n"
		"    :py:func:`RNA.file_commands_read()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"filename : const char *\n"
		"    The filename  \n"
		"options : unsigned int\n"
		"    Options to limit the type of commands read from the file  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.cmd()  \n"
		"    A list of abstract commands  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.commands_apply(), RNA.file_commands_apply(), RNA.commands_free()  \n"
		"\n"
		""},
	 { "enumerate_necklaces", (PyCFunction)(void(*)(void))_wrap_enumerate_necklaces, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Enumerate all necklaces with fixed content.  \n"
		"\n"
		"This function implements *A fast algorithm to generate necklaces with fixed content* as published by\n"
		":cite:t:`sawada:2003` .  \n"
		"\n"
		"The function receives a list of counts (the elements on the necklace) for each type of object within\n"
		"a necklace. The list starts at index 0 and ends with an entry that has a count of 0. The algorithm\n"
		"then enumerates all non-cyclic permutations of the content, returned as a list of necklaces. This\n"
		"list, again, is zero-terminated, i.e. the last entry of the list is a `NULL` pointer.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as global function `enumerate_necklaces()` which accepts lists input,\n"
		"    an produces list of lists output. See, e.g.    :py:func:`RNA.enumerate_necklaces()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"type_counts : const unsigned int *\n"
		"    A 0-terminated list of entity counts  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int **  \n"
		"    A list of all non-cyclic permutations of the entities  \n"
		"\n"
		""},
	 { "rotational_symmetry", _wrap_rotational_symmetry, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Determine the order of rotational symmetry for a NULL-terminated string of ASCII characters.  \n"
		"\n"
		"The algorithm applies a fast search of the provided string within itself, assuming the end of the\n"
		"string wraps around to connect with it's start. For example, a string of the form `AABAAB` has\n"
		"rotational symmetry of order `2`  \n"
		"\n"
		"If the argument `positions` is not `NULL`, the function stores an array of string start positions\n"
		"for rotational shifts that map the string back onto itself. This array has length of order of\n"
		"rotational symmetry, i.e. the number returned by this function. The first element `positions`[0]\n"
		"always contains a shift value of `0` representing the trivial rotation.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded global function `rotational_symmetry()`. It merges the\n"
		"    functionalities of RNA.rotational_symmetry(), RNA.rotational_symmetry_pos(),\n"
		"    RNA.rotational_symmetry_num(), and RNA.rotational_symmetry_pos_num(). In contrast to our\n"
		"    C-implementation, this function doesn't return the order of rotational symmetry as a single\n"
		"    value, but returns a list of cyclic permutation shifts that result in a rotationally symmetric\n"
		"    string. The length of the list then determines the order of rotational symmetry. See, e.g.\n"
		"    :py:func:`RNA.rotational_symmetry()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"string : const char *\n"
		"    A NULL-terminated string of characters  \n"
		"positions : unsigned int **\n"
		"    A pointer to an (undefined) list of alternative string start positions that lead to an identity\n"
		"    mapping (may be NULL)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int  \n"
		"    The order of rotational symmetry  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.rotational_symmetry(), RNA.rotational_symmetry_num(), RNA.rotational_symmetry_num_pos()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Do not forget to release the memory occupied by `positions` after a successful execution of this\n"
		"function.  \n"
		"\n"
		""},
	 { "boustrophedon", _wrap_boustrophedon, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Generate a sequence of Boustrophedon distributed numbers.  \n"
		"\n"
		"This function generates a sequence of positive natural numbers within the interval :math:`[start,\n"
		"end]` in a Boustrophedon fashion. That is, the numbers :math:`start, \\ldots, end` in the resulting\n"
		"list are alternating between left and right ends of the interval while progressing to the inside,\n"
		"i.e. the list consists of a sequence of natural numbers of the form:  \n"
		"\n"
		".. math::\n"
		"\n"
		"  start, end, start + 1, end - 1, start + 2, end - 2, \\ldots  \n"
		"\n"
		"The resulting list is 1-based and contains the length of the sequence of numbers at it's 0-th\n"
		"position.  \n"
		"\n"
		"Upon failure, the function returns **NULL**  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded global function `boustrophedon()`. See, e.g.\n"
		"    :py:func:`RNA.boustrophedon()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"start : size()\n"
		"    The first number of the list (left side of the interval)  \n"
		"end : size()\n"
		"    The last number of the list (right side of the interval)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int *  \n"
		"    A list of alternating numbers from the interval :math:`[start, end]` (or **NULL** on error)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.boustrophedon_pos()  \n"
		"\n"
		""},
	 { "n_multichoose_k", (PyCFunction)(void(*)(void))_wrap_n_multichoose_k, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "duplex_list_t_i_set", _wrap_duplex_list_t_i_set, METH_VARARGS, NULL},
	 { "duplex_list_t_i_get", _wrap_duplex_list_t_i_get, METH_O, NULL},
	 { "duplex_list_t_j_set", _wrap_duplex_list_t_j_set, METH_VARARGS, NULL},
	 { "duplex_list_t_j_get", _wrap_duplex_list_t_j_get, METH_O, NULL},
	 { "duplex_list_t_energy_set", _wrap_duplex_list_t_energy_set, METH_VARARGS, NULL},
	 { "duplex_list_t_energy_get", _wrap_duplex_list_t_energy_get, METH_O, NULL},
	 { "duplex_list_t_structure_set", _wrap_duplex_list_t_structure_set, METH_VARARGS, NULL},
	 { "duplex_list_t_structure_get", _wrap_duplex_list_t_structure_get, METH_O, NULL},
	 { "new_duplex_list_t", _wrap_new_duplex_list_t, METH_NOARGS, NULL},
	 { "delete_duplex_list_t", _wrap_delete_duplex_list_t, METH_O, NULL},
	 { "duplex_list_t_swigregister", duplex_list_t_swigregister, METH_O, NULL},
	 { "duplex_list_t_swiginit", duplex_list_t_swiginit, METH_VARARGS, NULL},
	 { "DuplexVector_iterator", _wrap_DuplexVector_iterator, METH_O, NULL},
	 { "DuplexVector___nonzero__", _wrap_DuplexVector___nonzero__, METH_O, NULL},
	 { "DuplexVector___bool__", _wrap_DuplexVector___bool__, METH_O, NULL},
	 { "DuplexVector___len__", _wrap_DuplexVector___len__, METH_O, NULL},
	 { "DuplexVector___getslice__", (PyCFunction)(void(*)(void))_wrap_DuplexVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DuplexVector___setslice__", _wrap_DuplexVector___setslice__, METH_VARARGS, NULL},
	 { "DuplexVector___delslice__", (PyCFunction)(void(*)(void))_wrap_DuplexVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DuplexVector___delitem__", _wrap_DuplexVector___delitem__, METH_VARARGS, NULL},
	 { "DuplexVector___getitem__", _wrap_DuplexVector___getitem__, METH_VARARGS, NULL},
	 { "DuplexVector___setitem__", _wrap_DuplexVector___setitem__, METH_VARARGS, NULL},
	 { "DuplexVector_pop", _wrap_DuplexVector_pop, METH_O, NULL},
	 { "DuplexVector_append", (PyCFunction)(void(*)(void))_wrap_DuplexVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DuplexVector_empty", _wrap_DuplexVector_empty, METH_O, NULL},
	 { "DuplexVector_size", _wrap_DuplexVector_size, METH_O, NULL},
	 { "DuplexVector_swap", (PyCFunction)(void(*)(void))_wrap_DuplexVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DuplexVector_begin", _wrap_DuplexVector_begin, METH_O, NULL},
	 { "DuplexVector_end", _wrap_DuplexVector_end, METH_O, NULL},
	 { "DuplexVector_rbegin", _wrap_DuplexVector_rbegin, METH_O, NULL},
	 { "DuplexVector_rend", _wrap_DuplexVector_rend, METH_O, NULL},
	 { "DuplexVector_clear", _wrap_DuplexVector_clear, METH_O, NULL},
	 { "DuplexVector_get_allocator", _wrap_DuplexVector_get_allocator, METH_O, NULL},
	 { "DuplexVector_pop_back", _wrap_DuplexVector_pop_back, METH_O, NULL},
	 { "DuplexVector_erase", _wrap_DuplexVector_erase, METH_VARARGS, NULL},
	 { "new_DuplexVector", _wrap_new_DuplexVector, METH_VARARGS, NULL},
	 { "DuplexVector_push_back", (PyCFunction)(void(*)(void))_wrap_DuplexVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DuplexVector_front", _wrap_DuplexVector_front, METH_O, NULL},
	 { "DuplexVector_back", _wrap_DuplexVector_back, METH_O, NULL},
	 { "DuplexVector_assign", (PyCFunction)(void(*)(void))_wrap_DuplexVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DuplexVector_resize", _wrap_DuplexVector_resize, METH_VARARGS, NULL},
	 { "DuplexVector_insert", _wrap_DuplexVector_insert, METH_VARARGS, NULL},
	 { "DuplexVector_reserve", (PyCFunction)(void(*)(void))_wrap_DuplexVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "DuplexVector_capacity", _wrap_DuplexVector_capacity, METH_O, NULL},
	 { "delete_DuplexVector", _wrap_delete_DuplexVector, METH_O, NULL},
	 { "DuplexVector_swigregister", DuplexVector_swigregister, METH_O, NULL},
	 { "DuplexVector_swiginit", DuplexVector_swiginit, METH_VARARGS, NULL},
	 { "duplexfold", (PyCFunction)(void(*)(void))_wrap_duplexfold, METH_VARARGS|METH_KEYWORDS, "\n"
		"duplexfold(std::string s1, std::string s2) -> duplex_list_t\n"
		"\n"
		"\n"
		""},
	 { "duplex_subopt", (PyCFunction)(void(*)(void))_wrap_duplex_subopt, METH_VARARGS|METH_KEYWORDS, "\n"
		"duplex_subopt(std::string s1, std::string s2, int delta, int w) -> DuplexVector\n"
		"\n"
		"\n"
		""},
	 { "aliduplexfold", (PyCFunction)(void(*)(void))_wrap_aliduplexfold, METH_VARARGS|METH_KEYWORDS, "\n"
		"aliduplexfold(StringVector alignment1, StringVector alignment2) -> duplex_list_t\n"
		"\n"
		"\n"
		""},
	 { "aliduplex_subopt", (PyCFunction)(void(*)(void))_wrap_aliduplex_subopt, METH_VARARGS|METH_KEYWORDS, "\n"
		"aliduplex_subopt(StringVector alignment1, StringVector alignment2, int delta, int w) -> DuplexVector\n"
		"\n"
		"\n"
		""},
	 { "get_concentrations", (PyCFunction)(void(*)(void))_wrap_get_concentrations, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "equilibrium_constants", (PyCFunction)(void(*)(void))_wrap_equilibrium_constants, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "equilibrium_conc", (PyCFunction)(void(*)(void))_wrap_equilibrium_conc, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "move_pos_5_set", _wrap_move_pos_5_set, METH_VARARGS, NULL},
	 { "move_pos_5_get", _wrap_move_pos_5_get, METH_O, NULL},
	 { "move_pos_3_set", _wrap_move_pos_3_set, METH_VARARGS, NULL},
	 { "move_pos_3_get", _wrap_move_pos_3_get, METH_O, NULL},
	 { "new_move", (PyCFunction)(void(*)(void))_wrap_new_move, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"An atomic representation of the transition / move from one structure to its neighbor.  \n"
		"\n"
		"An atomic transition / move may be one of the following:  \n"
		"\n"
		"*   a **base pair insertion**,  \n"
		"*   a **base pair removal**, or  \n"
		"*   a **base pair shift** where an existing base pair changes one of its pairing partner.  \n"
		"\n"
		"These moves are encoded by two integer values that represent the affected 5' and 3' nucleotide\n"
		"positions. Furthermore, we use the following convention on the signedness of these encodings:  \n"
		"\n"
		"*   both values are positive for *insertion moves*  \n"
		"*   both values are negative for *base pair removals*  \n"
		"*   both values have different signedness for *shift moves*, where the positive value indicates the\n"
		"    nucleotide that stays constant, and the others absolute value is the new pairing partner  \n"
		"\n"
		"Note\n"
		"----\n"
		"A value of 0 in either field is used as list-end indicator and doesn't represent any valid move.  \n"
		"\n"
		"Attributes\n"
		"----------\n"
		"pos_5 : int  \n"
		"    The (absolute value of the) 5' position of a base pair, or any position of a shifted pair.  \n"
		"\n"
		"pos_3 : int  \n"
		"    The (absolute value of the) 3' position of a base pair, or any position of a shifted pair.  \n"
		"\n"
		"next : vrna_move_t *  \n"
		"    The next base pair (if an elementary move changes more than one base pair), or `NULL` Has to be\n"
		"    terminated with move 0,0.  \n"
		"\n"
		""},
	 { "delete_move", _wrap_delete_move, METH_O, NULL},
	 { "move_is_removal", _wrap_move_is_removal, METH_O, "\n"
		"\n"
		"\n"
		"Test whether a move is a base pair removal.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero if the move is a base pair removal, 0 otherwise  \n"
		"\n"
		""},
	 { "move_is_insertion", _wrap_move_is_insertion, METH_O, "\n"
		"\n"
		"\n"
		"Test whether a move is a base pair insertion.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero if the move is a base pair insertion, 0 otherwise  \n"
		"\n"
		""},
	 { "move_is_shift", _wrap_move_is_shift, METH_O, "\n"
		"\n"
		"\n"
		"Test whether a move is a base pair shift.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero if the move is a base pair shift, 0 otherwise  \n"
		"\n"
		""},
	 { "move_compare", (PyCFunction)(void(*)(void))_wrap_move_compare, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compare two moves.  \n"
		"\n"
		"The function compares two moves `m` and `b` and returns whether move `m` is lexicographically\n"
		"smaller (-1), larger (1) or equal to move `b`.  \n"
		"\n"
		"If any of the moves `m` or `b` is a shift move, this comparison only makes sense in a structure\n"
		"context. Thus, the third argument with the current structure must be provided.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"b : const RNA.move() *\n"
		"    The second move of the comparison  \n"
		"pt : const short *\n"
		"    The pair table of the current structure that is compatible with both moves (maybe NULL if moves\n"
		"    are guaranteed to be no shifts)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    -1 if `m` < `b`, 1 if `m` > `b`, 0 otherwise  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"Currently, shift moves are not supported!  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function returns 0 (equality) upon any error, e.g. missing input  \n"
		"\n"
		""},
	 { "move___str__", _wrap_move___str__, METH_O, NULL},
	 { "move_swigregister", move_swigregister, METH_O, NULL},
	 { "move_swiginit", move_swiginit, METH_VARARGS, NULL},
	 { "path_type_set", _wrap_path_type_set, METH_VARARGS, NULL},
	 { "path_type_get", _wrap_path_type_get, METH_O, NULL},
	 { "path_en_set", _wrap_path_en_set, METH_VARARGS, NULL},
	 { "path_en_get", _wrap_path_en_get, METH_O, NULL},
	 { "path_s_set", _wrap_path_s_set, METH_VARARGS, NULL},
	 { "path_s_get", _wrap_path_s_get, METH_O, NULL},
	 { "path_move_set", _wrap_path_move_set, METH_VARARGS, NULL},
	 { "path_move_get", _wrap_path_move_get, METH_O, NULL},
	 { "new_path", (PyCFunction)(void(*)(void))_wrap_new_path, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "delete_path", _wrap_delete_path, METH_O, NULL},
	 { "path___str__", _wrap_path___str__, METH_O, NULL},
	 { "path_swigregister", path_swigregister, METH_O, NULL},
	 { "path_swiginit", path_swiginit, METH_VARARGS, NULL},
	 { "new_path_options", _wrap_new_path_options, METH_NOARGS, NULL},
	 { "delete_path_options", _wrap_delete_path_options, METH_O, NULL},
	 { "path_options_swigregister", path_options_swigregister, METH_O, NULL},
	 { "path_options_swiginit", path_options_swiginit, METH_VARARGS, NULL},
	 { "path_options_findpath", (PyCFunction)(void(*)(void))_wrap_path_options_findpath, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Create options data structure for findpath direct (re-)folding path heuristic.  \n"
		"\n"
		"This function returns an options data structure that switches the RNA.path_direct() and\n"
		"RNA.fold_compound.path_direct() API functions to use the *findpath*  :cite:p:`flamm:2001`  heuristic. The\n"
		"parameter `width` specifies the width of the breadth-first search while the second parameter `type`\n"
		"allows one to set the type of the returned (re-)folding path.  \n"
		"\n"
		"Currently, the following return types are available:  \n"
		"\n"
		"*   A list of dot-bracket structures and corresponding free energy (flag:\n"
		"    RNA.PATH_TYPE_DOT_BRACKET)  \n"
		"*   A list of transition moves and corresponding free energy changes (flag: RNA.PATH_TYPE_MOVES)  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `path_options_findpath()`. The optional\n"
		"    parameter `width` defaults to 10 if omitted, while the optional parameter `type` defaults to\n"
		"    RNA.PATH_TYPE_DOT_BRACKET. See, e.g.   :py:func:`RNA.path_options_findpath()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"width : int\n"
		"    Width of the breath-first search strategy  \n"
		"type : unsigned int\n"
		"    Setting that specifies how the return (re-)folding path should be encoded  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.path_options()  \n"
		"    An options data structure with settings for the findpath direct path heuristic  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.PATH_TYPE_DOT_BRACKET, RNA.PATH_TYPE_MOVES, RNA.path_options_free(), RNA.path_direct(),\n"
		"RNA.fold_compound.path_direct()  \n"
		"\n"
		""},
	 { "get_path", (PyCFunction)(void(*)(void))_wrap_get_path, METH_VARARGS|METH_KEYWORDS, "get_path(std::string seq, std::string s1, std::string s2, int maxkeep) -> PathVector"},
	 { "find_saddle", (PyCFunction)(void(*)(void))_wrap_find_saddle, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Find energy of a saddle point between 2 structures (search only direct path).  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.path_findpath_saddle() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seq : const char *\n"
		"    RNA sequence  \n"
		"s1 : const char *\n"
		"    A pointer to the character array where the first secondary structure in dot-bracket notation\n"
		"    will be written to  \n"
		"s2 : const char *\n"
		"    A pointer to the character array where the second secondary structure in dot-bracket notation\n"
		"    will be written to  \n"
		"width : int\n"
		"    integer how many strutures are being kept during the search  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    the saddle energy in 10cal/mol  \n"
		"\n"
		""},
	 { "free_path", (PyCFunction)(void(*)(void))_wrap_free_path, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Free memory allocated by get_path() function.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    Use RNA.path_free() instead!  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"path : RNA.path() *\n"
		"    pointer to memory to be freed  \n"
		"\n"
		""},
	 { "heat_capacity_result_temperature_set", _wrap_heat_capacity_result_temperature_set, METH_VARARGS, NULL},
	 { "heat_capacity_result_temperature_get", _wrap_heat_capacity_result_temperature_get, METH_O, NULL},
	 { "heat_capacity_result_heat_capacity_set", _wrap_heat_capacity_result_heat_capacity_set, METH_VARARGS, NULL},
	 { "heat_capacity_result_heat_capacity_get", _wrap_heat_capacity_result_heat_capacity_get, METH_O, NULL},
	 { "heat_capacity_result___str__", _wrap_heat_capacity_result___str__, METH_O, NULL},
	 { "new_heat_capacity_result", _wrap_new_heat_capacity_result, METH_NOARGS, NULL},
	 { "delete_heat_capacity_result", _wrap_delete_heat_capacity_result, METH_O, NULL},
	 { "heat_capacity_result_swigregister", heat_capacity_result_swigregister, METH_O, NULL},
	 { "heat_capacity_result_swiginit", heat_capacity_result_swiginit, METH_VARARGS, NULL},
	 { "HeatCapacityVector_iterator", _wrap_HeatCapacityVector_iterator, METH_O, NULL},
	 { "HeatCapacityVector___nonzero__", _wrap_HeatCapacityVector___nonzero__, METH_O, NULL},
	 { "HeatCapacityVector___bool__", _wrap_HeatCapacityVector___bool__, METH_O, NULL},
	 { "HeatCapacityVector___len__", _wrap_HeatCapacityVector___len__, METH_O, NULL},
	 { "HeatCapacityVector___getslice__", (PyCFunction)(void(*)(void))_wrap_HeatCapacityVector___getslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HeatCapacityVector___setslice__", _wrap_HeatCapacityVector___setslice__, METH_VARARGS, NULL},
	 { "HeatCapacityVector___delslice__", (PyCFunction)(void(*)(void))_wrap_HeatCapacityVector___delslice__, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HeatCapacityVector___delitem__", _wrap_HeatCapacityVector___delitem__, METH_VARARGS, NULL},
	 { "HeatCapacityVector___getitem__", _wrap_HeatCapacityVector___getitem__, METH_VARARGS, NULL},
	 { "HeatCapacityVector___setitem__", _wrap_HeatCapacityVector___setitem__, METH_VARARGS, NULL},
	 { "HeatCapacityVector_pop", _wrap_HeatCapacityVector_pop, METH_O, NULL},
	 { "HeatCapacityVector_append", (PyCFunction)(void(*)(void))_wrap_HeatCapacityVector_append, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HeatCapacityVector_empty", _wrap_HeatCapacityVector_empty, METH_O, NULL},
	 { "HeatCapacityVector_size", _wrap_HeatCapacityVector_size, METH_O, NULL},
	 { "HeatCapacityVector_swap", (PyCFunction)(void(*)(void))_wrap_HeatCapacityVector_swap, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HeatCapacityVector_begin", _wrap_HeatCapacityVector_begin, METH_O, NULL},
	 { "HeatCapacityVector_end", _wrap_HeatCapacityVector_end, METH_O, NULL},
	 { "HeatCapacityVector_rbegin", _wrap_HeatCapacityVector_rbegin, METH_O, NULL},
	 { "HeatCapacityVector_rend", _wrap_HeatCapacityVector_rend, METH_O, NULL},
	 { "HeatCapacityVector_clear", _wrap_HeatCapacityVector_clear, METH_O, NULL},
	 { "HeatCapacityVector_get_allocator", _wrap_HeatCapacityVector_get_allocator, METH_O, NULL},
	 { "HeatCapacityVector_pop_back", _wrap_HeatCapacityVector_pop_back, METH_O, NULL},
	 { "HeatCapacityVector_erase", _wrap_HeatCapacityVector_erase, METH_VARARGS, NULL},
	 { "new_HeatCapacityVector", _wrap_new_HeatCapacityVector, METH_VARARGS, NULL},
	 { "HeatCapacityVector_push_back", (PyCFunction)(void(*)(void))_wrap_HeatCapacityVector_push_back, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HeatCapacityVector_front", _wrap_HeatCapacityVector_front, METH_O, NULL},
	 { "HeatCapacityVector_back", _wrap_HeatCapacityVector_back, METH_O, NULL},
	 { "HeatCapacityVector_assign", (PyCFunction)(void(*)(void))_wrap_HeatCapacityVector_assign, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HeatCapacityVector_resize", _wrap_HeatCapacityVector_resize, METH_VARARGS, NULL},
	 { "HeatCapacityVector_insert", _wrap_HeatCapacityVector_insert, METH_VARARGS, NULL},
	 { "HeatCapacityVector_reserve", (PyCFunction)(void(*)(void))_wrap_HeatCapacityVector_reserve, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "HeatCapacityVector_capacity", _wrap_HeatCapacityVector_capacity, METH_O, NULL},
	 { "delete_HeatCapacityVector", _wrap_delete_HeatCapacityVector, METH_O, NULL},
	 { "HeatCapacityVector_swigregister", HeatCapacityVector_swigregister, METH_O, NULL},
	 { "HeatCapacityVector_swiginit", HeatCapacityVector_swiginit, METH_VARARGS, NULL},
	 { "heat_capacity", (PyCFunction)(void(*)(void))_wrap_heat_capacity, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute the specific heat for an RNA (simplified variant).  \n"
		"\n"
		"Similar to RNA.fold_compound.heat_capacity(), this function computes an RNAs specific heat in a given temperature\n"
		"range from the partition function by numeric differentiation. This simplified version, however, only\n"
		"requires the RNA sequence as input instead of a RNA.fold_compound() data structure. The result is\n"
		"returned as a list of pairs of temperature in C and specific heat in Kcal/(Mol*K).  \n"
		"\n"
		"Users can specify the temperature range for the computation from `T_min` to `T_max`, as well as the\n"
		"increment step size `T_increment`. The latter also determines how many times the partition function\n"
		"is computed. Finally, the parameter `mpoints` determines how smooth the curve should be. The\n"
		"algorithm itself fits a parabola to :math:`2 \\cdot mpoints + 1` data points to calculate 2nd\n"
		"derivatives. Increasing this parameter produces a smoother curve.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is available as overloaded function `heat_capacity()`. If the optional function\n"
		"    arguments `T_min`, `T_max`, `T_increment`, and `mpoints` are omitted, they default to 0.0,\n"
		"    100.0, 1.0 and 2, respectively. See, e.g.   :py:func:`RNA.head_capacity()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"sequence : const char *\n"
		"    The RNA sequence input (must be uppercase)  \n"
		"T_min : float\n"
		"    Lowest temperature in C  \n"
		"T_max : float\n"
		"    Highest temperature in C  \n"
		"T_increment : float\n"
		"    Stepsize for temperature incrementation in C (a reasonable choice might be 1C)  \n"
		"mpoints : unsigned int\n"
		"    The number of interpolation points to calculate 2nd derivative (a reasonable choice might be 2,\n"
		"    min: 1, max: 100)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.heat_capacity() *  \n"
		"    A list of pairs of temperatures and corresponding heat capacity or *NULL* upon any failure. The\n"
		"    last entry of the list is indicated by a **temperature** field set to a value smaller than\n"
		"    `T_min`  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.heat_capacity(), RNA.fold_compound.heat_capacity_cb(), RNA.heat_capacity(),\n"
		"RNA.heat_capacity()  \n"
		"\n"
		""},
	 { "fc_add_pycallback", (PyCFunction)(void(*)(void))_wrap_fc_add_pycallback, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "fc_add_pydata", (PyCFunction)(void(*)(void))_wrap_fc_add_pydata, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "sc_add_f_pycallback", (PyCFunction)(void(*)(void))_wrap_sc_add_f_pycallback, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "sc_add_bt_pycallback", (PyCFunction)(void(*)(void))_wrap_sc_add_bt_pycallback, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "sc_add_exp_f_pycallback", (PyCFunction)(void(*)(void))_wrap_sc_add_exp_f_pycallback, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "sc_add_pydata", (PyCFunction)(void(*)(void))_wrap_sc_add_pydata, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ud_set_pydata", (PyCFunction)(void(*)(void))_wrap_ud_set_pydata, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ud_set_prod_cb", (PyCFunction)(void(*)(void))_wrap_ud_set_prod_cb, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ud_set_exp_prod_cb", (PyCFunction)(void(*)(void))_wrap_ud_set_exp_prod_cb, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "ud_set_prob_cb", (PyCFunction)(void(*)(void))_wrap_ud_set_prob_cb, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "Lfold_cb", (PyCFunction)(void(*)(void))_wrap_Lfold_cb, METH_VARARGS|METH_KEYWORDS, "Lfold_cb(char * string, int window_size, PyObject * PyFunc, PyObject * data) -> float"},
	 { "Lfoldz_cb", (PyCFunction)(void(*)(void))_wrap_Lfoldz_cb, METH_VARARGS|METH_KEYWORDS, "Lfoldz_cb(char * string, int window_size, double min_z, PyObject * PyFunc, PyObject * data) -> float"},
	 { "aliLfold_cb", (PyCFunction)(void(*)(void))_wrap_aliLfold_cb, METH_VARARGS|METH_KEYWORDS, "aliLfold_cb(StringVector alignment, int window_size, PyObject * PyFunc, PyObject * data) -> float"},
	 { "pfl_fold_cb", (PyCFunction)(void(*)(void))_wrap_pfl_fold_cb, METH_VARARGS|METH_KEYWORDS, "pfl_fold_cb(std::string sequence, int window_size, int max_bp_span, PyObject * PyFunc, PyObject * data=Py_None) -> int"},
	 { "pfl_fold_up_cb", (PyCFunction)(void(*)(void))_wrap_pfl_fold_up_cb, METH_VARARGS|METH_KEYWORDS, "pfl_fold_up_cb(std::string sequence, int ulength, int window_size, int max_bp_span, PyObject * PyFunc, PyObject * data=Py_None) -> int"},
	 { "sc_multi_cb_add_pycallback", (PyCFunction)(void(*)(void))_wrap_sc_multi_cb_add_pycallback, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "fold_compound_params_reset", (PyCFunction)(void(*)(void))_wrap_fold_compound_params_reset, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Reset free energy parameters within a RNA.fold_compound() according to provided, or default model\n"
		"details.  \n"
		"\n"
		"This function allows one to rescale free energy parameters for subsequent structure prediction or\n"
		"evaluation according to a set of model details, e.g. temperature values. To do so, the caller\n"
		"provides either a pointer to a set of model details to be used for rescaling, or NULL if global\n"
		"default setting should be used.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached to RNA.fc() objects as overloaded `params_reset()` method.  \n"
		"\n"
		"    When no parameter is passed to this method, the resulting action is the same as passing `NULL`\n"
		"    as second parameter to RNA.fold_compound.params_reset(), i.e. global default model settings are\n"
		"    used. Passing\n"
		"    an object of type RNA.md() resets the fold compound according to the specifications stored\n"
		"    within the RNA.md() object. See, e.g.   :py:meth:`RNA.fold_compound.params_reset()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"md : RNA.md() *\n"
		"    A pointer to the new model details (or NULL for reset to defaults)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.exp_params_reset(), RNA.params_subs()  \n"
		"\n"
		""},
	 { "fold_compound_params_subst", (PyCFunction)(void(*)(void))_wrap_fold_compound_params_subst, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Update/Reset energy parameters data structure within a RNA.fold_compound().  \n"
		"\n"
		"Passing NULL as second argument leads to a reset of the energy parameters within fc to their default\n"
		"values. Otherwise, the energy parameters provided will be copied over into fc.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached to RNA.fc() objects as overloaded `params_subst()` method.  \n"
		"\n"
		"    When no parameter is passed, the resulting action is the same as passing `NULL` as second\n"
		"    parameter to RNA.fold_compound.params_subst(), i.e. resetting the parameters to the global\n"
		"    defaults. See,\n"
		"    e.g.   :py:meth:`RNA.fold_compound.params_subst()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"par : RNA.param() *\n"
		"    The energy parameters used to substitute those within fc (Maybe NULL)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.params_reset(), RNA.param(), RNA.md(), RNA.params()  \n"
		"\n"
		""},
	 { "fold_compound_exp_params_rescale", _wrap_fold_compound_exp_params_rescale, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Rescale Boltzmann factors for partition function computations.  \n"
		"\n"
		"This function may be used to (automatically) rescale the Boltzmann factors used in partition\n"
		"function computations. Since partition functions over subsequences can easily become extremely\n"
		"large, the RNAlib internally rescales them to avoid numerical over- and/or underflow. Therefore, a\n"
		"proper scaling factor :math:`s` needs to be chosen that in turn is then used to normalize the\n"
		"corresponding partition functions :math:`\\hat{q}[i,j] = q[i,j] / s^{(j-i+1)}`.  \n"
		"\n"
		"This function provides two ways to automatically adjust the scaling factor.  \n"
		"\n"
		"1.  Automatic guess  \n"
		"2.  Automatic adjustment according to MFE  \n"
		"\n"
		"Passing `NULL` as second parameter activates the *automatic guess mode*. Here, the scaling factor is\n"
		"recomputed according to a mean free energy of `184.3*length` cal for random sequences.\n"
		"On the other hand, if the MFE for a sequence is known, it can be used to recompute a more robust\n"
		"scaling factor, since it represents the lowest free energy of the entire ensemble of structures,\n"
		"i.e. the highest Boltzmann factor. To activate this second mode of *automatic adjustment according\n"
		"to MFE*, a pointer to the MFE value needs to be passed as second argument. This value is then taken\n"
		"to compute the scaling factor as :math:`s = exp((sfact * MFE) / kT / length )`, where sfact is an\n"
		"additional scaling weight located in the RNA.md() data structure of `exp_params` in `fc`.  \n"
		"\n"
		"Note\n"
		"----\n"
		"This recomputation only takes place if the `pf_scale` attribute of the `exp_params` data structure\n"
		"contained in `fc` has a value below `1.0`.  \n"
		"\n"
		"The computed scaling factor :math:`s` will be stored as `pf_scale` attribute of the `exp_params`\n"
		"data structure in `fc`.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached to RNA.fc() objects as overloaded `exp_params_rescale()` method.  \n"
		"\n"
		"    When no parameter is passed to this method, the resulting action is the same as passing `NULL`\n"
		"    as second parameter to RNA.fold_compound.exp_params_rescale(), i.e. default scaling of the\n"
		"    partition\n"
		"    function. Passing an energy in kcal/mol, e.g. as retrieved by a previous call to the `mfe()`\n"
		"    method, instructs all subsequent calls to scale the partition function accordingly. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.exp_params_rescale()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"mfe : double *\n"
		"    A pointer to the MFE (in kcal/mol) or NULL  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.exp_params_subst(), RNA.md(), RNA.exp_param(), RNA.fold_compound()  \n"
		"\n"
		""},
	 { "fold_compound_exp_params_reset", (PyCFunction)(void(*)(void))_wrap_fold_compound_exp_params_reset, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Reset Boltzmann factors for partition function computations within a RNA.fold_compound() according\n"
		"to provided, or default model details.  \n"
		"\n"
		"This function allows one to rescale Boltzmann factors for subsequent partition function computations\n"
		"according to a set of model details, e.g. temperature values. To do so, the caller provides either a\n"
		"pointer to a set of model details to be used for rescaling, or NULL if global default setting should\n"
		"be used.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached to RNA.fc() objects as overloaded `exp_params_reset()` method.  \n"
		"\n"
		"    When no parameter is passed to this method, the resulting action is the same as passing `NULL`\n"
		"    as second parameter to RNA.fold_compound.exp_params_reset(), i.e. global default model settings\n"
		"    are used.\n"
		"    Passing an object of type RNA.md() resets the fold compound according to the specifications\n"
		"    stored within the RNA.md() object. See, e.g.   :py:meth:`RNA.fold_compound.exp_params_reset()`\n"
		"    in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"md : RNA.md() *\n"
		"    A pointer to the new model details (or NULL for reset to defaults)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.params_reset(), RNA.fold_compound.exp_params_subst(),\n"
		"RNA.fold_compound.exp_params_rescale()  \n"
		"\n"
		""},
	 { "fold_compound_exp_params_subst", (PyCFunction)(void(*)(void))_wrap_fold_compound_exp_params_subst, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Update the energy parameters for subsequent partition function computations.  \n"
		"\n"
		"This function can be used to properly assign new energy parameters for partition function\n"
		"computations to a RNA.fold_compound(). For this purpose, the data of the provided pointer `params`\n"
		"will be copied into `fc` and a recomputation of the partition function scaling factor is issued, if\n"
		"the `pf_scale` attribute of `params` is less than `1.0`.  \n"
		"\n"
		"Passing NULL as second argument leads to a reset of the energy parameters within fc to their default\n"
		"values  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached to RNA.fc() objects as overloaded `exp_params_subst()` method.  \n"
		"\n"
		"    When no parameter is passed, the resulting action is the same as passing `NULL` as second\n"
		"    parameter to RNA.fold_compound.exp_params_subst(), i.e. resetting the parameters to the global\n"
		"    defaults. See,\n"
		"    e.g.   :py:meth:`RNA.fold_compound.exp_params_subst()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"params : RNA.exp_param() *\n"
		"    A pointer to the new energy parameters  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.exp_params_reset(), RNA.fold_compound.exp_params_rescale(), RNA.exp_param(),\n"
		"RNA.md(), RNA.exp_params()  \n"
		"\n"
		""},
	 { "fold_compound_plist_from_probs", (PyCFunction)(void(*)(void))_wrap_fold_compound_plist_from_probs, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_plist_from_probs(fold_compound self, double cutoff) -> ElemProbVector\n"
		"\n"
		"\n"
		"Create a RNA.ep() from base pair probability matrix.  \n"
		"\n"
		"The probability matrix provided via the RNA.fold_compound() is parsed and all pair probabilities\n"
		"above the given threshold are used to create an entry in the plist  \n"
		"\n"
		"The end of the plist is marked by sequence positions i as well as j equal to 0. This condition\n"
		"should be used to stop looping over its entries  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cut_off : double\n"
		"    The cutoff value  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.ep() *  \n"
		"    A pointer to the plist that is to be created  \n"
		"\n"
		""},
	 { "fold_compound_db_from_probs", _wrap_fold_compound_db_from_probs, METH_O, NULL},
	 { "fold_compound_constraints_add", (PyCFunction)(void(*)(void))_wrap_fold_compound_constraints_add, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_constraints_add(fold_compound self, char const * constraint, unsigned int options=)\n"
		"\n"
		"\n"
		"Add constraints to a RNA.fold_compound() data structure.  \n"
		"\n"
		"Use this function to add/update the hard/soft constraints The function allows for passing a string\n"
		"'constraint' that can either be a filename that points to a constraints definition file or it may be\n"
		"a pseudo dot-bracket notation indicating hard constraints. For the latter, the user has to pass the\n"
		"RNA.CONSTRAINT_DB option. Also, the user has to specify, which characters are allowed to be\n"
		"interpreted as constraints by passing the corresponding options via the third parameter.  \n"
		"\n"
		"The following is an example for adding hard constraints given in pseudo dot-bracket notation. Here,\n"
		"`fc` is the RNA.fold_compound() object, `structure` is a char array with the hard constraint in\n"
		"dot-bracket notation, and `enforceConstraints` is a flag indicating whether or not constraints for\n"
		"base pairs should be enforced instead of just doing a removal of base pair that conflict with the\n"
		"constraint.  \n"
		"\n"
		"\n"
		"In constrat to the above, constraints may also be read from file:  \n"
		"\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"constraint : const char *\n"
		"    A string with either the filename of the constraint definitions or a pseudo dot-bracket notation\n"
		"    of the hard constraint. May be NULL.  \n"
		"options : unsigned int\n"
		"    The option flags  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.hc_add_from_db(), RNA.fold_compound.hc_add_up(), RNA.hc_add_up_batch()\n"
		"RNA.hc_add_bp_unspecific(),\n"
		"RNA.fold_compound.hc_add_bp(), RNA.fold_compound.hc_init(), RNA.fold_compound.sc_set_up(),\n"
		"RNA.fold_compound.sc_set_bp(), RNA.fold_compound.sc_add_SHAPE_deigan(),\n"
		"RNA.fold_compound.sc_add_SHAPE_zarringhalam(), RNA.hc_free(), RNA.sc_free(), RNA.CONSTRAINT_DB,\n"
		"RNA.CONSTRAINT_DB_DEFAULT, RNA.CONSTRAINT_DB_PIPE, RNA.CONSTRAINT_DB_DOT, RNA.CONSTRAINT_DB_X,\n"
		"RNA.CONSTRAINT_DB_ANG_BRACK, RNA.CONSTRAINT_DB_RND_BRACK, RNA.CONSTRAINT_DB_INTRAMOL,\n"
		"RNA.CONSTRAINT_DB_INTERMOL, RNA.CONSTRAINT_DB_GQUAD  \n"
		"\n"
		""},
	 { "fold_compound_hc_init", _wrap_fold_compound_hc_init, METH_O, "\n"
		"\n"
		"\n"
		"Initialize/Reset hard constraints to default values.  \n"
		"\n"
		"This function resets the hard constraints to their default values, i.e. all positions may be\n"
		"unpaired in all contexts, and base pairs are allowed in all contexts, if they resemble canonical\n"
		"pairs. Previously set hard constraints will be removed before initialization.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `hc_init()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.hc_init()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.hc_add_bp(), RNA.fold_compound.hc_add_bp_nonspecific(),\n"
		"RNA.fold_compound.hc_add_up()  \n"
		"\n"
		""},
	 { "fold_compound_hc_add_up", (PyCFunction)(void(*)(void))_wrap_fold_compound_hc_add_up, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_hc_add_up(fold_compound self, unsigned int i, unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS)\n"
		"\n"
		"\n"
		"Make a certain nucleotide unpaired.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : unsigned int\n"
		"    The position that needs to stay unpaired (1-based)  \n"
		"option : unsigned char\n"
		"    The options flag indicating how/where to store the hard constraints  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.hc_add_bp(), RNA.fold_compound.hc_add_bp_nonspecific(),\n"
		"RNA.fold_compound.hc_init(), RNA.CONSTRAINT_CONTEXT_EXT_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_HP_LOOP, RNA.CONSTRAINT_CONTEXT_INT_LOOP, RNA.CONSTRAINT_CONTEXT_MB_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_ALL_LOOPS  \n"
		"\n"
		""},
	 { "fold_compound_hc_add_up_strand", (PyCFunction)(void(*)(void))_wrap_fold_compound_hc_add_up_strand, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "fold_compound_hc_add_bp_nonspecific", (PyCFunction)(void(*)(void))_wrap_fold_compound_hc_add_bp_nonspecific, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_hc_add_bp_nonspecific(fold_compound self, unsigned int i, int d, unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS)\n"
		"\n"
		"\n"
		"Enforce a nucleotide to be paired (upstream/downstream).  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : unsigned int\n"
		"    The position that needs to stay unpaired (1-based)  \n"
		"d : int\n"
		"    The direction of base pairing ( :math:`d < 0`: pairs upstream, :math:`d > 0`: pairs downstream,\n"
		"    :math:`d == 0`: no direction)  \n"
		"option : unsigned char\n"
		"    The options flag indicating in which loop type context the pairs may appear  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.hc_add_bp(), RNA.fold_compound.hc_add_up(), RNA.fold_compound.hc_init(),\n"
		"RNA.CONSTRAINT_CONTEXT_EXT_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_HP_LOOP, RNA.CONSTRAINT_CONTEXT_INT_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_INT_LOOP_ENC, RNA.CONSTRAINT_CONTEXT_MB_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_MB_LOOP_ENC, RNA.CONSTRAINT_CONTEXT_ALL_LOOPS  \n"
		"\n"
		""},
	 { "fold_compound_hc_add_bp", (PyCFunction)(void(*)(void))_wrap_fold_compound_hc_add_bp, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_hc_add_bp(fold_compound self, unsigned int i, unsigned int j, unsigned int option=VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS)\n"
		"\n"
		"\n"
		"Favorize/Enforce a certain base pair (i,j).  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : unsigned int\n"
		"    The 5' located nucleotide position of the base pair (1-based)  \n"
		"j : unsigned int\n"
		"    The 3' located nucleotide position of the base pair (1-based)  \n"
		"option : unsigned char\n"
		"    The options flag indicating how/where to store the hard constraints  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.hc_add_bp_nonspecific(), RNA.fold_compound.hc_add_up(),\n"
		"RNA.fold_compound.hc_init(), RNA.CONSTRAINT_CONTEXT_EXT_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_HP_LOOP, RNA.CONSTRAINT_CONTEXT_INT_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_INT_LOOP_ENC, RNA.CONSTRAINT_CONTEXT_MB_LOOP,\n"
		"RNA.CONSTRAINT_CONTEXT_MB_LOOP_ENC, RNA.CONSTRAINT_CONTEXT_ENFORCE,\n"
		"RNA.CONSTRAINT_CONTEXT_ALL_LOOPS  \n"
		"\n"
		""},
	 { "fold_compound_hc_add_bp_strand", (PyCFunction)(void(*)(void))_wrap_fold_compound_hc_add_bp_strand, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "fold_compound_hc_add_from_db", (PyCFunction)(void(*)(void))_wrap_fold_compound_hc_add_from_db, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_hc_add_from_db(fold_compound self, char const * constraint, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Add hard constraints from pseudo dot-bracket notation.  \n"
		"\n"
		"This function allows one to apply hard constraints from a pseudo dot-bracket notation. The `options`\n"
		"parameter controls, which characters are recognized by the parser. Use the\n"
		"RNA.CONSTRAINT_DB_DEFAULT convenience macro, if you want to allow all known characters  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `hc_add_from_db()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.hc_add_from_db()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"constraint : const char *\n"
		"    A pseudo dot-bracket notation of the hard constraint.  \n"
		"options : unsigned int\n"
		"    The option flags  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.CONSTRAINT_DB_PIPE, RNA.CONSTRAINT_DB_DOT, RNA.CONSTRAINT_DB_X, RNA.CONSTRAINT_DB_ANG_BRACK,\n"
		"RNA.CONSTRAINT_DB_RND_BRACK, RNA.CONSTRAINT_DB_INTRAMOL, RNA.CONSTRAINT_DB_INTERMOL,\n"
		"RNA.CONSTRAINT_DB_GQUAD  \n"
		"\n"
		""},
	 { "fold_compound_sc_remove", _wrap_fold_compound_sc_remove, METH_O, "\n"
		"\n"
		"\n"
		"Remove soft constraints from RNA.fold_compound().  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_remove()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_remove()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Note\n"
		"----\n"
		"Accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE and RNA.FC_TYPE_COMPARATIVE  \n"
		"\n"
		""},
	 { "fold_compound_sc_init", _wrap_fold_compound_sc_init, METH_O, "\n"
		"\n"
		"\n"
		"Initialize an empty soft constraints data structure within a RNA.fold_compound().  \n"
		"\n"
		"This function adds a proper soft constraints data structure to the RNA.fold_compound() data\n"
		"structure. If soft constraints already exist within the fold compound, they are removed.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_init()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_init()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_set_bp(), RNA.fold_compound.sc_set_up(),\n"
		"RNA.fold_compound.sc_add_SHAPE_deigan(), RNA.fold_compound.sc_add_SHAPE_zarringhalam(),\n"
		"RNA.fold_compound.sc_remove(), RNA.fold_compound.sc_add(), RNA.fold_compound.sc_add_exp(),\n"
		"RNA.sc_add_pre(), RNA.sc_add_post()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE and RNA.FC_TYPE_COMPARATIVE  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_up", _wrap_fold_compound_sc_add_up, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add soft constraints for unpaired nucleotides.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `sc_add_up()` to objects of type\n"
		"    `fold_compound`. The method either takes arguments for a single nucleotide :math:`i` with the\n"
		"    corresponding energy value:  \n"
		" or an entire vector that stores free energy contributions for each nucleotide :math:`i` with\n"
		" :math:`1 \\leq i \\leq n`:  In both variants, the optional argument `options` defaults to\n"
		" RNA.OPTION_DEFAULT. See, e.g.    :py:meth:`RNA.fold_compound.sc_add_up()` in the\n"
		" :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : unsigned int\n"
		"    The nucleotide position the soft constraint is added for  \n"
		"energy : FLT_OR_DBL\n"
		"    The free energy (soft-constraint) in :math:`kcal / mol`  \n"
		"options : unsigned int\n"
		"    The options flag indicating how/where to store the soft constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful application of the constraint, 0 otherwise.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_set_up(), RNA.fold_compound.sc_add_bp(), RNA.fold_compound.sc_set_bp(),\n"
		"RNA.sc_add_up_comparative()  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_bp", _wrap_fold_compound_sc_add_bp, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Add soft constraints for paired nucleotides.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `sc_add_bp()` to objects of type\n"
		"    `fold_compound`. The method either takes arguments for a single base pair (i,j) with the\n"
		"    corresponding energy value:  \n"
		" or an entire 2-dimensional matrix with dimensions n x n that stores free energy contributions for\n"
		" any base pair (i,j) with :math:`1 \\leq i < j \\leq n`:  In both variants, the optional argument\n"
		" `options` defaults to RNA.OPTION_DEFAULT. See, e.g.    :py:meth:`RNA.fold_compound.sc_add_bp()` in\n"
		" the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : unsigned int\n"
		"    The 5' position of the base pair the soft constraint is added for  \n"
		"j : unsigned int\n"
		"    The 3' position of the base pair the soft constraint is added for  \n"
		"energy : FLT_OR_DBL\n"
		"    The free energy (soft-constraint) in :math:`kcal / mol`  \n"
		"options : unsigned int\n"
		"    The options flag indicating how/where to store the soft constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful application of the constraint, 0 otherwise.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_set_bp(), RNA.fold_compound.sc_set_up(), RNA.fold_compound.sc_add_up()  \n"
		"\n"
		""},
	 { "fold_compound_sc_set_bp", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_set_bp, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_set_bp(fold_compound self, DoubleDoubleVector constraints, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Set soft constraints for paired nucleotides.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_set_bp()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_set_bp()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"constraints : const FLT_OR_DBL **\n"
		"    A two-dimensional array of pseudo free energies in :math:`kcal / mol`  \n"
		"options : unsigned int\n"
		"    The options flag indicating how/where to store the soft constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful application of the constraint, 0 otherwise.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_add_bp(), RNA.fold_compound.sc_set_up(), RNA.fold_compound.sc_add_up()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function replaces any pre-exisitng soft constraints with the ones supplied in `constraints`.  \n"
		"\n"
		""},
	 { "fold_compound_sc_set_up", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_set_up, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_set_up(fold_compound self, DoubleVector constraints, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Set soft constraints for unpaired nucleotides.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_set_up()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_set_up()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"constraints : const FLT_OR_DBL *\n"
		"    A vector of pseudo free energies in :math:`kcal / mol`  \n"
		"options : unsigned int\n"
		"    The options flag indicating how/where to store the soft constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful application of the constraint, 0 otherwise.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_add_up(), RNA.fold_compound.sc_set_bp(), RNA.fold_compound.sc_add_bp()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function replaces any pre-exisitng soft constraints with the ones supplied in `constraints`.  \n"
		"\n"
		""},
	 { "fold_compound_sc_set_stack", _wrap_fold_compound_sc_set_stack, METH_VARARGS, "\n"
		"fold_compound_sc_set_stack(fold_compound self, DoubleVector constraints, unsigned int options=) -> int\n"
		"fold_compound_sc_set_stack(fold_compound self, DoubleDoubleVector constraints, unsigned int options=) -> int\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_sc_add_stack", _wrap_fold_compound_sc_add_stack, METH_VARARGS, "\n"
		"fold_compound_sc_add_stack(fold_compound self, unsigned int i, double energy, unsigned int options=) -> int\n"
		"fold_compound_sc_add_stack(fold_compound self, UIntVector i, DoubleVector energies, unsigned int options=) -> int\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_sc_add_hi_motif", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_hi_motif, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_hi_motif(fold_compound self, char const * seq, char const * structure, FLT_OR_DBL energy, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Add soft constraints for hairpin or internal loop binding motif.  \n"
		"\n"
		"Here is an example that adds a theophylline binding motif. Free energy contribution is derived from\n"
		":math:`k_{d} = 0.1 \\mu M`, taken from Jenison et al. 1994. At :math:`1M` concentration the\n"
		"corresponding binding free energy amounts to :math:`-9.93~kcal/mol`.  \n"
		"\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add_hi_motif()` to objects of type `fold_compound`. The\n"
		"    last parameter is optional an defaults to `options` = RNA.OPTION_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_add_hi_motif()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"seq : const char *\n"
		"    The sequence motif (may be interspaced by '&' character  \n"
		"structure : const char *\n"
		"    The structure motif (may be interspaced by '&' character  \n"
		"energy : FLT_OR_DBL\n"
		"    The free energy of the motif (e.g. binding free energy)  \n"
		"options : unsigned int\n"
		"    Options  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    non-zero value if application of the motif using soft constraints was successful  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_json", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_json, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Prepare soft constraint callbacks for modified base as specified in JSON string.  \n"
		"\n"
		"This function prepares all requirements to acknowledge modified bases as specified in the provided\n"
		"`json` string. All subsequent predictions will treat each modification site special and adjust\n"
		"energy contributions if necessary.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_json()` to objects of type\n"
		"    `fold_compound` with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_json()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"json : const char *\n"
		"    The JSON formatted string with the modified base parameters  \n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_mod_jsonfile(), RNA.fold_compound.sc_mod(), RNA.fold_compound.sc_mod_m6A(),\n"
		"RNA.fold_compound.sc_mod_pseudouridine(),\n"
		"RNA.fold_compound.sc_mod_inosine(), RNA.fold_compound.sc_mod_7DA(),\n"
		"RNA.fold_compound.sc_mod_purine(), RNA.fold_compound.sc_mod_dihydrouridine(),\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT,\n"
		"modified-bases-params  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_jsonfile", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_jsonfile, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Prepare soft constraint callbacks for modified base as specified in JSON string.  \n"
		"\n"
		"Similar to RNA.fold_compound.sc_mod_json(), this function prepares all requirements to acknowledge modified bases\n"
		"as specified in the provided `json` file. All subsequent predictions will treat each modification\n"
		"site special and adjust energy contributions if necessary.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_jsonfile()` to objects of type\n"
		"    `fold_compound` with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_jsonfile()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"json :\n"
		"    The JSON formatted string with the modified base parameters  \n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_mod_json(), RNA.fold_compound.sc_mod(), RNA.fold_compound.sc_mod_m6A(),\n"
		"RNA.fold_compound.sc_mod_pseudouridine(),\n"
		"RNA.fold_compound.sc_mod_inosine(), RNA.fold_compound.sc_mod_7DA(),\n"
		"RNA.fold_compound.sc_mod_purine(), RNA.fold_compound.sc_mod_dihydrouridine(),\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT,\n"
		"modified-bases-params  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Prepare soft constraint callbacks for modified base as specified in JSON string.  \n"
		"\n"
		"This function takes a RNA.sc_mod_param() data structure as obtained from\n"
		"RNA.sc_mod_read_from_json() or RNA.sc_mod_read_from_jsonfile() and prepares all requirements to\n"
		"acknowledge modified bases as specified in the provided `params` data structure. All subsequent\n"
		"predictions will treat each modification site special and adjust energy contributions if necessary.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod()` to objects of type `fold_compound`\n"
		"    with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.    :py:meth:`RNA.fold_compound.sc_mod()`\n"
		"    in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"json :\n"
		"    The JSON formatted string with the modified base parameters  \n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.sc_mod_read_from_json(), RNA.sc_mod_read_from_jsonfile(), RNA.fold_compound.sc_mod_json(),\n"
		"RNA.fold_compound.sc_mod_jsonfile(), RNA.fold_compound.sc_mod_m6A(),\n"
		"RNA.fold_compound.sc_mod_pseudouridine(), RNA.fold_compound.sc_mod_inosine(),\n"
		"RNA.fold_compound.sc_mod_7DA(), RNA.fold_compound.sc_mod_purine(),\n"
		"RNA.sc_mod_dihydrouridine()RNA.SC_MOD_CHECK_FALLBACK,\n"
		"RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_m6A", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_m6A, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Add soft constraint callbacks for N6-methyl-adenosine (m6A).  \n"
		"\n"
		"This is a convenience wrapper to add support for m6A using the soft constraint callback mechanism.\n"
		"Modification sites are provided as a list of sequence positions (1-based). Energy parameter\n"
		"corrections are derived from    :cite:t:`kierzek:2022` .  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_m6A()` to objects of type `fold_compound`\n"
		"    with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_m6A()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_pseudouridine", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_pseudouridine, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Add soft constraint callbacks for Pseudouridine.  \n"
		"\n"
		"This is a convenience wrapper to add support for pseudouridine using the soft constraint callback\n"
		"mechanism. Modification sites are provided as a list of sequence positions (1-based). Energy\n"
		"parameter corrections are derived from    :cite:t:`hudson:2013` .  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_pseudouridine()` to objects of type\n"
		"    `fold_compound` with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_pseudouridine()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_inosine", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_inosine, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Add soft constraint callbacks for Inosine.  \n"
		"\n"
		"This is a convenience wrapper to add support for inosine using the soft constraint callback\n"
		"mechanism. Modification sites are provided as a list of sequence positions (1-based). Energy\n"
		"parameter corrections are derived from    :cite:t:`wright:2007`  and    :cite:t:`wright:2018` .  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_inosine()` to objects of type\n"
		"    `fold_compound` with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_inosine()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_7DA", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_7DA, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Add soft constraint callbacks for 7-deaza-adenosine (7DA).  \n"
		"\n"
		"This is a convenience wrapper to add support for 7-deaza-adenosine using the soft constraint\n"
		"callback mechanism. Modification sites are provided as a list of sequence positions (1-based).\n"
		"Energy parameter corrections are derived from    :cite:t:`richardson:2016` .  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_7DA()` to objects of type `fold_compound`\n"
		"    with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_7DA()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_purine", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_purine, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Add soft constraint callbacks for Purine (a.k.a. nebularine).  \n"
		"\n"
		"This is a convenience wrapper to add support for Purine using the soft constraint callback\n"
		"mechanism. Modification sites are provided as a list of sequence positions (1-based). Energy\n"
		"parameter corrections are derived from    :cite:t:`jolley:2017` .  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_purine()` to objects of type\n"
		"    `fold_compound` with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_purine()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_sc_mod_dihydrouridine", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_mod_dihydrouridine, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Add soft constraint callbacks for dihydrouridine.  \n"
		"\n"
		"This is a convenience wrapper to add support for dihydrouridine using the soft constraint callback\n"
		"mechanism. Modification sites are provided as a list of sequence positions (1-based). Energy\n"
		"parameter corrections are derived from Rosetta/RECESS predictions.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `sc_mod_dihydrouridine()` to objects of type\n"
		"    `fold_compound` with default `options` = RNA.SC_MOD_DEFAULT. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_mod_dihydrouridine()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"modification_sites : const unsigned int *\n"
		"    A list of modification site, i.e. positions that contain the modified base (1-based, last\n"
		"    element in the list indicated by 0)  \n"
		"options : unsigned int\n"
		"    A bitvector of options how to handle the input, e.g. RNA.SC_MOD_DEFAULT  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Number of sequence positions modified base parameters will be used for  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.SC_MOD_CHECK_FALLBACK, RNA.SC_MOD_CHECK_UNMOD, RNA.SC_MOD_SILENT, RNA.SC_MOD_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_sc_probing", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_probing, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_probing(fold_compound self, probing_data data) -> int\n"
		"\n"
		"\n"
		"Apply probing data (e.g. SHAPE) to guide the structure prediction.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method **sc_probing()** to objects of type **fold_compound**. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.sc_probing()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"data : RNA.probing_data()\n"
		"    The prepared probing data and probing data integration strategy  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The number of probing data sets applied, 0 upon any error  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.probing_data(), RNA.probing_data_free(), RNA.probing_data_deigan(),\n"
		"RNA.probing_data_deigan_comparative(), RNA.probing_data_zarringhalam(),\n"
		"RNA.probing_data_zarringhalam_comparative(), RNA.probing_data_eddy(),\n"
		"RNA.probing_data_eddy_comparative()  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_SHAPE_deigan", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_SHAPE_deigan, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_SHAPE_deigan(fold_compound self, DoubleVector reactivities, double m, double b, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Add SHAPE reactivity data as soft constraints (Deigan et al. method).  \n"
		"\n"
		"This approach of SHAPE directed RNA folding uses the simple linear ansatz  \n"
		"\n"
		".. math::\n"
		"\n"
		"  \\Delta G_{\\text{SHAPE}}(i) = m \\ln(\\text{SHAPE reactivity}(i)+1)+ b  \n"
		"\n"
		"to convert SHAPE reactivity values to pseudo energies whenever a nucleotide :math:`i` contributes to\n"
		"a stacked pair. A positive slope :math:`m` penalizes high reactivities in paired regions, while a\n"
		"negative intercept :math:`b` results in a confirmatory *bonus* free energy for correctly predicted\n"
		"base pairs. Since the energy evaluation of a base pair stack involves two pairs, the pseudo energies\n"
		"are added for all four contributing nucleotides. Consequently, the energy term is applied twice for\n"
		"pairs inside a helix and only once for pairs adjacent to other structures. For all other loop types\n"
		"the energy model remains unchanged even when the experimental data highly disagrees with a certain\n"
		"motif.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add_SHAPE_deigan()` to objects of type `fold_compound`.\n"
		"    See, e.g.    :py:meth:`RNA.fold_compound.sc_add_SHAPE_deigan()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"reactivities : const double *\n"
		"    A vector of normalized SHAPE reactivities  \n"
		"m : double\n"
		"    The slope of the conversion function  \n"
		"b : double\n"
		"    The intercept of the conversion function  \n"
		"options : unsigned int\n"
		"    The options flag indicating how/where to store the soft constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on successful extraction of the method, 0 on errors  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_remove(), RNA.fold_compound.sc_add_SHAPE_zarringhalam(),\n"
		"RNA.sc_minimize_pertubation()  \n"
		"\n"
		"Note\n"
		"----\n"
		"For further details, we refer to    :cite:t:`deigan:2009` .  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_SHAPE_deigan_ali", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_SHAPE_deigan_ali, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_SHAPE_deigan_ali(fold_compound self, StringVector shape_files, IntVector shape_file_association, double m, double b, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Add SHAPE reactivity data from files as soft constraints for consensus structure prediction (Deigan\n"
		"et al. method).  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add_SHAPE_deigan_ali()` to objects of type\n"
		"    `fold_compound`. See, e.g.    :py:meth:`RNA.fold_compound.sc_add_SHAPE_deigan_ali()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"shape_files : const char **\n"
		"    A set of filenames that contain normalized SHAPE reactivity data  \n"
		"shape_file_association : const int *\n"
		"    An array of integers that associate the files with sequences in the alignment  \n"
		"m : double\n"
		"    The slope of the conversion function  \n"
		"b : double\n"
		"    The intercept of the conversion function  \n"
		"options : unsigned int\n"
		"    The options flag indicating how/where to store the soft constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on successful extraction of the method, 0 on errors  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_SHAPE_zarringhalam", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_SHAPE_zarringhalam, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_SHAPE_zarringhalam(fold_compound self, DoubleVector reactivities, double b, double default_value, char const * shape_conversion, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Add SHAPE reactivity data as soft constraints (Zarringhalam et al. method).  \n"
		"\n"
		"This method first converts the observed SHAPE reactivity of nucleotide :math:`i` into a probability\n"
		":math:`q_{i}` that position :math:`i` is unpaired by means of a non-linear map. Then pseudo-energies\n"
		"of the form  \n"
		"\n"
		".. math::\n"
		"\n"
		"  \\Delta G_{\\text{SHAPE}}(x,i) = \\beta\\ |x_{i} - q_{i}|  \n"
		"\n"
		"are computed, where :math:`x_{i}=0` if position :math:`i` is unpaired and :math:`x_{i}=1` if\n"
		":math:`i` is paired in a given secondary structure. The parameter :math:`\\beta` serves as scaling\n"
		"factor. The magnitude of discrepancy between prediction and experimental observation is represented\n"
		"by :math:`|x_{i} - q_{i}|`.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add_SHAPE_zarringhalam()` to objects of type\n"
		"    `fold_compound`. See, e.g.    :py:meth:`RNA.fold_compound.sc_add_SHAPE_zarringhalam()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"reactivities : const double *\n"
		"    A vector of normalized SHAPE reactivities  \n"
		"b : double\n"
		"    The scaling factor :math:`\\beta` of the conversion function  \n"
		"default_value : double\n"
		"    The default value for a nucleotide where reactivity data is missing for  \n"
		"shape_conversion : const char *\n"
		"    A flag that specifies how to convert reactivities to probabilities  \n"
		"options : unsigned int\n"
		"    The options flag indicating how/where to store the soft constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    1 on successful extraction of the method, 0 on errors  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_remove(), RNA.fold_compound.sc_add_SHAPE_deigan(),\n"
		"RNA.sc_minimize_pertubation()  \n"
		"\n"
		"Note\n"
		"----\n"
		"For further details, we refer to    :cite:t:`zarringhalam:2012`  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_SHAPE_eddy_2", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_SHAPE_eddy_2, METH_VARARGS|METH_KEYWORDS, "fold_compound_sc_add_SHAPE_eddy_2(fold_compound self, DoubleVector reactivities, DoubleVector unpaired_data, DoubleVector paired_data) -> int"},
	 { "fold_compound_eval_structure", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA.  \n"
		"\n"
		"This function allows for energy evaluation of a given pair of structure and sequence (alignment).\n"
		"Model details, energy parameters, and possibly soft constraints are used as provided via the\n"
		"parameter 'fc'. The RNA.fold_compound() does not need to contain any DP matrices, but requires all\n"
		"most basic init values as one would get from a call like this:  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_structure()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.eval_structure()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_structure_pt(), RNA.fold_compound.eval_structure_verbose(),\n"
		"RNA.fold_compound.eval_structure_pt_verbose(),\n"
		"RNA.fold_compound(), RNA.fold_compound_comparative(), RNA.fold_compound.eval_covar_structure()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE and RNA.FC_TYPE_COMPARATIVE  \n"
		"\n"
		""},
	 { "fold_compound_eval_structure_pt", _wrap_fold_compound_eval_structure_pt, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA.  \n"
		"\n"
		"This function allows for energy evaluation of a given sequence/structure pair where the structure is\n"
		"provided in pair_table format as obtained from RNA.ptable(). Model details, energy parameters, and\n"
		"possibly soft constraints are used as provided via the parameter 'fc'. The fold_compound does not\n"
		"need to contain any DP matrices, but all the most basic init values as one would get from a call\n"
		"like this:  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_structure_pt()` to objects of type `fold_compound`.\n"
		"    See, e.g.    :py:meth:`RNA.fold_compound.eval_structure_pt()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : const short *\n"
		"    Secondary structure as pair_table  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The free energy of the input structure given the input sequence in 10cal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.ptable(), RNA.fold_compound.eval_structure(), RNA.fold_compound.eval_structure_pt_verbose()  \n"
		"\n"
		""},
	 { "fold_compound_eval_structure_verbose", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_structure_verbose, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA and print contributions on a per-loop base.  \n"
		"\n"
		"This function is a simplyfied version of RNA.eval_structure_v() that uses the *default* verbosity\n"
		"level.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_structure_verbose()` to objects of type\n"
		"    `fold_compound`. See, e.g.    :py:meth:`RNA.fold_compound.eval_structure_verbose()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    Secondary structure in dot-bracket notation  \n"
		"file : FILE *\n"
		"    A file handle where this function should print to (may be NULL).  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The free energy of the input structure given the input sequence in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_structure_pt(), RNA.fold_compound.eval_structure_verbose(),\n"
		"RNA.fold_compound.eval_structure_pt_verbose(),  \n"
		"\n"
		""},
	 { "fold_compound_eval_structure_pt_verbose", _wrap_fold_compound_eval_structure_pt_verbose, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate the free energy of an already folded RNA.  \n"
		"\n"
		"This function is a simplyfied version of RNA.eval_structure_simple_v() that uses the *default*\n"
		"verbosity level.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_structure_pt_verbose()` to objects of type\n"
		"    `fold_compound`. See, e.g.    :py:meth:`RNA.fold_compound.eval_structure_pt_verbose()` in the\n"
		"    :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : const short *\n"
		"    Secondary structure as pair_table  \n"
		"file : FILE *\n"
		"    A file handle where this function should print to (may be NULL).  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The free energy of the input structure given the input sequence in 10cal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.eval_structure_pt_v(), RNA.ptable(), RNA.fold_compound.eval_structure_pt(),\n"
		"RNA.fold_compound.eval_structure_verbose()  \n"
		"\n"
		""},
	 { "fold_compound_eval_covar_structure", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_covar_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate the pseudo energy derived by the covariance scores of a set of aligned sequences.  \n"
		"\n"
		"Consensus structure prediction is driven by covariance scores of base pairs in rows of the provided\n"
		"alignment. This function allows one to retrieve the total amount of this covariance pseudo energy\n"
		"scores. The RNA.fold_compound() does not need to contain any DP matrices, but requires all most\n"
		"basic init values as one would get from a call like this:  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_covar_structure()` to objects of type `fold_compound`.\n"
		"    See, e.g.    :py:meth:`RNA.fold_compound.eval_covar_structure()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    Secondary (consensus) structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The covariance pseudo energy score of the input structure given the input sequence alignment in\n"
		"    kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound_comparative(), RNA.fold_compound.eval_structure()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Accepts RNA.fold_compound() of type RNA.FC_TYPE_COMPARATIVE only!  \n"
		"\n"
		""},
	 { "fold_compound_eval_loop_pt", _wrap_fold_compound_eval_loop_pt, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate energy of a loop.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_loop_pt()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.eval_loop_pt()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"i : int\n"
		"    position of covering base pair  \n"
		"pt : const short *\n"
		"    the pair table of the secondary structure  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    free energy of the loop in 10cal/mol  \n"
		"\n"
		""},
	 { "fold_compound_eval_move", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_move, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Calculate energy of a move (closing or opening of a base pair).  \n"
		"\n"
		"If the parameters m1 and m2 are negative, it is deletion (opening) of a base pair, otherwise it is\n"
		"insertion (opening).  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_move()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.eval_move()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    secondary structure in dot-bracket notation  \n"
		"m1 : int\n"
		"    first coordinate of base pair  \n"
		"m2 : int\n"
		"    second coordinate of base pair  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    energy change of the move in kcal/mol (INF / 100. upon any error)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_move_pt()  \n"
		"\n"
		""},
	 { "fold_compound_eval_move_pt", _wrap_fold_compound_eval_move_pt, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Calculate energy of a move (closing or opening of a base pair).  \n"
		"\n"
		"If the parameters m1 and m2 are negative, it is deletion (opening) of a base pair, otherwise it is\n"
		"insertion (opening).  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_move_pt()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.eval_move_pt()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : short *\n"
		"    the pair table of the secondary structure  \n"
		"m1 : int\n"
		"    first coordinate of base pair  \n"
		"m2 : int\n"
		"    second coordinate of base pair  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    energy change of the move in 10cal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.eval_move()  \n"
		"\n"
		""},
	 { "fold_compound_eval_ext_stem", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_ext_stem, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_E_hp_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_E_hp_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_E_ext_hp_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_E_ext_hp_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_eval_ext_hp_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_ext_hp_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_eval_hp_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_hp_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_eval_hp_loop(fold_compound self, int i, int j) -> int\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_hp_loop()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.eval_hp_loop()` in the :doc:`/api_python` .  \n"
		"\n"
		""},
	 { "fold_compound_exp_E_hp_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_exp_E_hp_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_E_int_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_E_int_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_eval_int_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_eval_int_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_eval_int_loop(fold_compound self, int i, int j, int k, int l) -> int\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `eval_int_loop()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.eval_int_loop()` in the :doc:`/api_python` .  \n"
		"\n"
		""},
	 { "fold_compound_E_ext_int_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_E_ext_int_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_E_stack", (PyCFunction)(void(*)(void))_wrap_fold_compound_E_stack, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_exp_E_int_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_exp_E_int_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_exp_E_interior_loop", (PyCFunction)(void(*)(void))_wrap_fold_compound_exp_E_interior_loop, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_exp_E_ext_stem", (PyCFunction)(void(*)(void))_wrap_fold_compound_exp_E_ext_stem, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_maxmimum_matching", _wrap_fold_compound_maxmimum_matching, METH_O, NULL},
	 { "fold_compound_mfe", _wrap_fold_compound_mfe, METH_O, "\n"
		"mfe() -> (structure, energy)\n"
		"\n"
		"\n"
		"Compute minimum free energy and an appropriate secondary structure of an RNA sequence, or RNA\n"
		"sequence alignment.  \n"
		"\n"
		"Depending on the type of the provided RNA.fold_compound(), this function predicts the MFE for a\n"
		"single sequence (or connected component of multiple sequences), or an averaged MFE for a sequence\n"
		"alignment. If backtracking is activated, it also constructs the corresponding secondary structure,\n"
		"or consensus structure. Therefore, the second parameter, *structure*, has to point to an allocated\n"
		"block of memory with a size of at least :math:`\\mathrm{strlen}(\\mathrm{sequence})+1` to store the\n"
		"backtracked MFE structure. (For consensus structures, this is the length of the alignment + 1. If\n"
		"`NULL` is passed, no backtracking will be performed.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `Minimum Free Energy (MFE) Algorithms` to objects of type\n"
		"    `The Fold Compound`. The parameter `structure` is returned along with the MFE und must not be\n"
		"    provided. See e.g.   :py:meth:`RNA.fold_compound.mfe()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : char *\n"
		"    A pointer to the character array where the secondary structure in dot-bracket notation will be\n"
		"    written to (Maybe NULL)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    the minimum free energy (MFE) in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound(), RNA.fold_compound(), RNA.fold(), RNA.circfold(),\n"
		"RNA.fold_compound_comparative(), RNA.alifold(), RNA.circalifold()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is polymorphic. It accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE, and\n"
		"RNA.FC_TYPE_COMPARATIVE.  \n"
		"\n"
		""},
	 { "fold_compound_mfe_dimer", _wrap_fold_compound_mfe_dimer, METH_O, "\n"
		"fold_compound_mfe_dimer(fold_compound self) -> char *\n"
		"\n"
		"\n"
		"Compute the minimum free energy of two interacting RNA molecules.  \n"
		"\n"
		"The code is analog to the RNA.fold_compound.mfe() function.  \n"
		"\n"
		".. deprecated:: 2.7.2\n"
		"    This function is obsolete since RNA.fold_compound.mfe() can handle complexes multiple sequences\n"
		"    since v2.5.0.\n"
		"    Use RNA.fold_compound.mfe() for connected component MFE instead and compute MFEs of unconnected\n"
		"    states\n"
		"    separately.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `mfe_dimer()` to objects of type `The Fold Compound`. The\n"
		"    parameter `structure` is returned along with the MFE und must not be provided. See e.g.\n"
		"    :py:meth:`RNA.fold_compound.mfe_dimer()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : char *\n"
		"    Will hold the barcket dot structure of the dimer molecule  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    minimum free energy of the structure  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.mfe()  \n"
		"\n"
		""},
	 { "fold_compound_benchmark", (PyCFunction)(void(*)(void))_wrap_fold_compound_benchmark, METH_VARARGS|METH_KEYWORDS, "fold_compound_benchmark(fold_compound self, std::string gold, int fuzzy=0, unsigned int options=8) -> score"},
	 { "fold_compound_mfe_window", (PyCFunction)(void(*)(void))_wrap_fold_compound_mfe_window, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Local MFE prediction using a sliding window approach.  \n"
		"\n"
		"Computes minimum free energy structures using a sliding window approach, where base pairs may not\n"
		"span outside the window. In contrast to RNA.fold_compound.mfe(), where a maximum base pair span may be set using\n"
		"the RNA.md().max_bp_span attribute and one globally optimal structure is predicted, this function\n"
		"uses a sliding window to retrieve all locally optimal structures within each window. The size of the\n"
		"sliding window is set in the RNA.md().window_size attribute, prior to the retrieval of the\n"
		"RNA.fold_compound() using RNA.fold_compound() with option RNA.OPTION_WINDOW  \n"
		"\n"
		"The predicted structures are written on-the-fly, either to stdout, if a NULL pointer is passed as\n"
		"file parameter, or to the corresponding filehandle.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `Local (sliding window) MFE Prediction` to\n"
		"    objects of type `The Fold Compound`. The parameter `FILE` has default value of `NULL` and can be\n"
		"    omitted. See e.g.   :py:meth:`RNA.fold_compound.mfe_window()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"file : FILE *\n"
		"    The output file handle where predictions are written to (maybe NULL)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound(), RNA.fold_compound.mfe_window_zscore(), RNA.fold_compound.mfe(), RNA.Lfold(),\n"
		"RNA.Lfoldz(),\n"
		"RNA.OPTION_WINDOW, RNA.md().max_bp_span, RNA.md().window_size  \n"
		"\n"
		""},
	 { "fold_compound_mfe_window_zscore", (PyCFunction)(void(*)(void))_wrap_fold_compound_mfe_window_zscore, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Local MFE prediction using a sliding window approach (with z-score cut-off).  \n"
		"\n"
		"Computes minimum free energy structures using a sliding window approach, where base pairs may not\n"
		"span outside the window. This function is the z-score version of RNA.fold_compound.mfe_window(), i.e. only\n"
		"predictions above a certain z-score cut-off value are printed. As for RNA.fold_compound.mfe_window(), the size of\n"
		"the sliding window is set in the RNA.md().window_size attribute, prior to the retrieval of the\n"
		"RNA.fold_compound() using RNA.fold_compound() with option RNA.OPTION_WINDOW.  \n"
		"\n"
		"The predicted structures are written on-the-fly, either to stdout, if a NULL pointer is passed as\n"
		"file parameter, or to the corresponding filehandle.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `mfe_window_zscore()` to objects of type `The\n"
		"    Fold Compound`. The parameter `FILE` has default value of `NULL` and can be omitted. See e.g.\n"
		"    :py:meth:`RNA.fold_compound.mfe_window_zscore()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"min_z : double\n"
		"    The minimal z-score for a predicted structure to appear in the output  \n"
		"file : FILE *\n"
		"    The output file handle where predictions are written to (maybe NULL)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound(), RNA.fold_compound.mfe_window_zscore(), RNA.fold_compound.mfe(), RNA.Lfold(),\n"
		"RNA.Lfoldz(),\n"
		"RNA.OPTION_WINDOW, RNA.md().max_bp_span, RNA.md().window_size  \n"
		"\n"
		""},
	 { "fold_compound_zsc_filter_init", (PyCFunction)(void(*)(void))_wrap_fold_compound_zsc_filter_init, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_zsc_filter_update", (PyCFunction)(void(*)(void))_wrap_fold_compound_zsc_filter_update, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_zsc_filter_free", _wrap_fold_compound_zsc_filter_free, METH_O, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_zsc_filter_on", _wrap_fold_compound_zsc_filter_on, METH_O, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_zsc_filter_threshold", _wrap_fold_compound_zsc_filter_threshold, METH_O, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_zsc_compute", (PyCFunction)(void(*)(void))_wrap_fold_compound_zsc_compute, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_zsc_compute_raw", (PyCFunction)(void(*)(void))_wrap_fold_compound_zsc_compute_raw, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_backtrack", _wrap_fold_compound_backtrack, METH_VARARGS, "\n"
		"fold_compound_backtrack(fold_compound self, unsigned int length) -> char\n"
		"fold_compound_backtrack(fold_compound self) -> char *\n"
		"\n"
		"\n"
		"Backtrack an MFE (sub)structure.  \n"
		"\n"
		"This function allows one to backtrack the MFE structure for a (sub)sequence  \n"
		"\n"
		"**Precondition**\n"
		"    Requires pre-filled MFE dynamic programming matrices, i.e. one has to call\n"
		"    RNA.fold_compound.mfe() prior to\n"
		"    calling this function  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `backtrack()` to objects of type `The Fold\n"
		"    Compound`. The parameter `length` defaults to the total length of the RNA sequence and may be\n"
		"    omitted. The parameter `structure` is returned along with the MFE und must not be provided. See\n"
		"    e.g.   :py:meth:`RNA.fold_compound.backtrack()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"length : unsigned int\n"
		"    The length of the subsequence, starting from the 5' end  \n"
		"structure : char *\n"
		"    A pointer to the character array where the secondary structure in dot-bracket notation will be\n"
		"    written to. (Must have size of at least $p length + 1)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"float  \n"
		"    The minimum free energy (MFE) for the specified `length` in kcal/mol and a corresponding\n"
		"    secondary structure in dot-bracket notation (stored in `structure`)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.mfe(), RNA.fold_compound.pbacktrack5()  \n"
		"\n"
		"Note\n"
		"----\n"
		"On error, the function returns INF / 100. and stores the empty string in `structure`.  \n"
		"\n"
		""},
	 { "fold_compound_pf", _wrap_fold_compound_pf, METH_O, "\n"
		"\n"
		"\n"
		"Compute the partition function :math:`Q` for a given RNA sequence, or sequence alignment.  \n"
		"\n"
		"If *structure* is not a NULL pointer on input, it contains on return a string consisting of the\n"
		"letters \" . , | { } ( ) \" denoting bases that are essentially unpaired, weakly paired, strongly\n"
		"paired without preference, weakly upstream (downstream) paired, or strongly up- (down-)stream paired\n"
		"bases, respectively. If the model's compute_bpp is set to 0 base pairing probabilities will not be\n"
		"computed (saving CPU time), otherwise after calculations took place pr will contain the probability\n"
		"that bases *i* and *j* pair.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `pf()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.pf()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : char *\n"
		"    A pointer to the character array where position-wise pairing propensity will be stored. (Maybe\n"
		"    NULL)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"FLT_OR_DBL  \n"
		"    The ensemble free energy :math:`G = -RT \\cdot \\log(Q)` in kcal/mol  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound(), RNA.fold_compound(), RNA.pf_fold(), RNA.pf_circfold(),\n"
		"RNA.fold_compound_comparative(), RNA.pf_alifold(), RNA.pf_circalifold(), RNA.db_from_probs(),\n"
		"RNA.exp_params(), RNA.aln_pinfo()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is polymorphic. It accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE, and\n"
		"RNA.FC_TYPE_COMPARATIVE. Also, this function may return INF / 100. in case of contradicting\n"
		"constraints or numerical over-/underflow. In the latter case, a corresponding warning will be issued\n"
		"to `stdout`.  \n"
		"\n"
		""},
	 { "fold_compound_mean_bp_distance", _wrap_fold_compound_mean_bp_distance, METH_O, "\n"
		"\n"
		"\n"
		"Get the mean base pair distance in the thermodynamic ensemble.  \n"
		"\n"
		".. math::\n"
		"\n"
		"  <d> = \\sum_{a,b} p_{a} p_{b} d(S_{a},S_{b})  \n"
		"\n"
		"this can be computed from the pair probs :math:`p_{ij}` as  \n"
		"\n"
		".. math::\n"
		"\n"
		"  <d> = \\sum_{ij} p_{ij}(1-p_{ij})  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `mean_bp_distance()` to objects of type `fold_compound`.\n"
		"    See, e.g.   :py:meth:`RNA.fold_compound.mean_bp_distance()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double  \n"
		"    The mean pair distance of the structure ensemble  \n"
		"\n"
		""},
	 { "fold_compound_ensemble_defect", _wrap_fold_compound_ensemble_defect, METH_VARARGS, "\n"
		"\n"
		"\n"
		"Compute the Ensemble Defect for a given target structure.  \n"
		"\n"
		"This is a wrapper around **RNA.ensemble_defect_pt()**. Given a target structure :math:`s`, compute\n"
		"the average dissimilarity of a randomly drawn structure from the ensemble, i.e.:  \n"
		"\n"
		".. math::\n"
		"\n"
		"  ED(s) = 1 - \\frac{1}{n} \\sum_{ij, (i,j) \\in s} p_{ij} - \\frac{1}{n} \\sum_{i}(1 - s_{i})q_{i}  \n"
		"\n"
		"with sequence length :math:`n`, the probability :math:`p_{ij}` of a base pair :math:`(i,j)`, the\n"
		"probability :math:`q_{i} = 1 - \\sum_{j} p_{ij}` of nucleotide :math:`i` being unpaired, and the\n"
		"indicator variable :math:`s_{i} = 1` if :math:`\\exists (i,j) \\in s`, and :math:`s_{i} = 0`\n"
		"otherwise.  \n"
		"\n"
		"**Precondition**\n"
		"    The RNA.fold_compound() input parameter `fc` must contain a valid base pair probability matrix.\n"
		"    This means that partition function and base pair probabilities must have been computed using\n"
		"    `fc` before execution of this function!  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `ensemble_defect()` to objects of type `fold_compound`. Note\n"
		"    that the SWIG wrapper takes a structure in dot-bracket notation and converts it into a pair\n"
		"    table using RNA.ptable_from_string(). The resulting pair table is then internally passed to\n"
		"    RNA.ensemble_defect_pt(). To control which kind of matching brackets will be used during\n"
		"    conversion, the optional argument `options` can be used. See also the description of\n"
		"    RNA.ptable_from_string() for available options. (default: `RNA.BRACKETS_RND`). See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.ensemble_defect()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    A target structure in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"double  \n"
		"    The ensemble defect with respect to the target structure, or -1. upon failure, e.g. pre-\n"
		"    conditions are not met  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.pf(), RNA.pairing_probs(), RNA.ensemble_defect_pt()  \n"
		"\n"
		""},
	 { "fold_compound_positional_entropy", _wrap_fold_compound_positional_entropy, METH_O, "\n"
		"\n"
		"\n"
		"Compute a vector of positional entropies.  \n"
		"\n"
		"This function computes the positional entropies from base pair probabilities as  \n"
		"\n"
		".. math::\n"
		"\n"
		"  S(i) = - \\sum_{j} p_{ij} \\log(p_{ij}) - q_{i} \\log(q_{i})  \n"
		"\n"
		"with unpaired probabilities :math:`q_{i} = 1 - \\sum_{j} p_{ij}`.  \n"
		"\n"
		"Low entropy regions have little structural flexibility and the reliability of the predicted\n"
		"structure is high. High entropy implies many structural alternatives. While these alternatives may\n"
		"be functionally important, they make structure prediction more difficult and thus less reliable.  \n"
		"\n"
		"**Precondition**\n"
		"    This function requires pre-computed base pair probabilities! Thus, RNA.fold_compound.pf() must\n"
		"    be called\n"
		"    beforehand.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `positional_entropy()` to objects of type `fold_compound`.\n"
		"    See, e.g.   :py:meth:`RNA.fold_compound.positional_entropy()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Returns\n"
		"-------\n"
		"double *  \n"
		"    A 1-based vector of positional entropies :math:`S(i)`. (position 0 contains the sequence length)  \n"
		"\n"
		""},
	 { "fold_compound_pr_structure", (PyCFunction)(void(*)(void))_wrap_fold_compound_pr_structure, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute the equilibrium probability of a particular secondary structure.  \n"
		"\n"
		"The probability :math:`p(s)` of a particular secondary structure :math:`s` can be computed as  \n"
		"\n"
		".. math::\n"
		"\n"
		"  p(s) = \\frac{exp(-\\beta E(s)}{Z}  \n"
		"\n"
		"from the structures free energy :math:`E(s)` and the partition function  \n"
		"\n"
		".. math::\n"
		"\n"
		"  Z = \\sum_{s} exp(-\\beta E(s)),\\quad\\mathrm{with}\\quad\\beta = \\frac{1}{RT}  \n"
		"\n"
		"where :math:`R` is the gas constant and :math:`T` the thermodynamic temperature.  \n"
		"\n"
		"**Precondition**\n"
		"    The fold compound `fc` must have went through a call to RNA.fold_compound.pf() to fill the\n"
		"    dynamic\n"
		"    programming matrices with the corresponding partition function.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `pr_structure()` to objects of type `fold_compound`. See,\n"
		"    e.g.   :py:meth:`RNA.fold_compound.pr_structure()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The secondary structure to compute the probability for in dot-bracket notation  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"double  \n"
		"    The probability of the input structure (range :math:`[0:1]`)  \n"
		"\n"
		""},
	 { "fold_compound_pr_energy", (PyCFunction)(void(*)(void))_wrap_fold_compound_pr_energy, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `pr_energy()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.pr_energy()` in the :doc:`/api_python`.  \n"
		"\n"
		""},
	 { "fold_compound_pf_dimer", _wrap_fold_compound_pf_dimer, METH_O, "\n"
		"\n"
		"\n"
		"Calculate partition function and base pair probabilities of nucleic acid/nucleic acid dimers.  \n"
		"\n"
		"This is the cofold partition function folding.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `pf_dimer()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.pf_dimer()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : char *\n"
		"    Will hold the structure or constraints  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.dimer_pf()  \n"
		"    RNA.dimer_pf() structure containing a set of energies needed for concentration computations.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound() for how to retrieve the necessary data structure  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function may return INF / 100. for the `FA`, `FB`, `FAB`, `F0AB` members of the output data\n"
		"structure in case of contradicting constraints or numerical over-/underflow. In the latter case, a\n"
		"corresponding warning will be issued to `stdout`.  \n"
		"\n"
		""},
	 { "fold_compound_bpp", (PyCFunction)(void(*)(void))_wrap_fold_compound_bpp, METH_VARARGS|METH_KEYWORDS, NULL},
	 { "fold_compound_stack_prob", (PyCFunction)(void(*)(void))_wrap_fold_compound_stack_prob, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Compute stacking probabilities.  \n"
		"\n"
		"For each possible base pair :math:`(i,j)`, compute the probability of a stack :math:`(i,j)`,\n"
		":math:`(i+1, j-1)`.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `stack_prob()` to objects of type\n"
		"    `fold_compound`. The optional argument `cutoff` defaults to 1e-5. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.stack_prob()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"cutoff : double\n"
		"    A cutoff value that limits the output to stacks with :math:`p > \\textrm{cutoff}`.  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.ep() *  \n"
		"    A list of stacks with enclosing base pair :math:`(i,j)` and probabiltiy :math:`p`  \n"
		"\n"
		""},
	 { "fold_compound_centroid", _wrap_fold_compound_centroid, METH_O, "\n"
		"fold_compound_centroid(fold_compound self) -> char *\n"
		"\n"
		"\n"
		"Get the centroid structure of the ensemble.  \n"
		"\n"
		"The centroid is the structure with the minimal average distance to all other structures\n"
		":math:`<d(S)> = \\sum_{(i,j) \\in S} (1-p_{ij}) + \\sum_{(i,j) \\notin S} p_{ij}`  \n"
		"Thus, the centroid is simply the structure containing all pairs with :math:`p_{i}j>0.5` The distance\n"
		"of the centroid to the ensemble is written to the memory adressed by *dist*.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"dist : double *\n"
		"    A pointer to the distance variable where the centroid distance will be written to  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    The centroid structure of the ensemble in dot-bracket notation (`NULL` on error)  \n"
		"\n"
		""},
	 { "fold_compound_MEA", _wrap_fold_compound_MEA, METH_VARARGS, "\n"
		"fold_compound_MEA(fold_compound self) -> char\n"
		"fold_compound_MEA(fold_compound self, double gamma) -> char *\n"
		"\n"
		"\n"
		"Compute a MEA (maximum expected accuracy) structure.  \n"
		"\n"
		"The algorithm maximizes the expected accuracy  \n"
		"\n"
		".. math::\n"
		"\n"
		"  A(S) = \\sum_{(i,j) \\in S} 2 \\gamma p_{ij} + \\sum_{i \\notin S} p^u_{i}  \n"
		"\n"
		"Higher values of :math:`\\gamma` result in more base pairs of lower probability and thus higher\n"
		"sensitivity. Low values of :math:`\\gamma` result in structures containing only highly likely pairs\n"
		"(high specificity). The code of the MEA function also demonstrates the use of sparse dynamic\n"
		"programming scheme to reduce the time and memory complexity of folding.  \n"
		"\n"
		"**Precondition**\n"
		"    RNA.fold_compound.pf() must be executed on input parameter `fc`  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `MEA`(gamma = 1.) to objects of type\n"
		"    `fold_compound`. Note, that it returns the MEA structure and MEA value as a tuple\n"
		"    (MEA_structure, MEA). See, e.g.   :py:meth:`RNA.fold_compound.MEA()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"gamma : double\n"
		"    The weighting factor for base pairs vs. unpaired nucleotides  \n"
		"mea : float *\n"
		"    A pointer to a variable where the MEA value will be written to  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    An MEA structure (or NULL on any error)  \n"
		"\n"
		""},
	 { "fold_compound_subopt", (PyCFunction)(void(*)(void))_wrap_fold_compound_subopt, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_subopt(fold_compound self, int delta, int sorted=1, FILE * nullfile=None) -> SuboptVector\n"
		"\n"
		"\n"
		"Returns list of subopt structures or writes to fp.  \n"
		"\n"
		"This function produces **all** suboptimal secondary structures within 'delta' * 0.01 kcal/mol of the\n"
		"optimum, see    :cite:t:`wuchty:1999` . The results are either directly written to a 'fp' (if 'fp'\n"
		"is not NULL), or (fp==NULL) returned in a RNA.subopt_solution() * list terminated by an entry were\n"
		"the 'structure' member is NULL.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method **subopt()** to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.subopt()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"delta : int\n"
		"sorted : int\n"
		"    Sort results by energy in ascending order  \n"
		"fp : FILE *\n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.subopt_solution() *  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.subopt_cb(), RNA.fold_compound.subopt_zuker()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function requires all multibranch loop DP matrices for unique multibranch loop backtracing.\n"
		"Therefore, the supplied RNA.fold_compound()`fc` (argument 1) must be initialized with\n"
		"RNA.md().uniq_ML = 1, for instance like this:  \n"
		"\n"
		""},
	 { "fold_compound_subopt_zuker", _wrap_fold_compound_subopt_zuker, METH_O, "\n"
		"\n"
		"\n"
		"Compute Zuker type suboptimal structures.  \n"
		"\n"
		"Compute Suboptimal structures according to    :cite:t:`zuker:1989`  , i.e. for every possible base\n"
		"pair the minimum energy structure containing the resp. base pair. Returns a list of these structures\n"
		"and their energies.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method **subopt_zuker()** to objects of type `fold_compound`. See,\n"
		"    e.g.   :py:meth:`RNA.fold_compound.subopt_zuker()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.subopt_solution() *  \n"
		"    List of zuker suboptimal structures  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.subopt(), zukersubopt(), zukersubopt_par()  \n"
		"\n"
		""},
	 { "fold_compound_sequence_add", (PyCFunction)(void(*)(void))_wrap_fold_compound_sequence_add, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_sequence_remove", (PyCFunction)(void(*)(void))_wrap_fold_compound_sequence_remove, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_sequence_remove_all", _wrap_fold_compound_sequence_remove_all, METH_O, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_sequence_prepare", _wrap_fold_compound_sequence_prepare, METH_O, "\n"
		"\n"
		"\n"
		""},
	 { "fold_compound_ud_add_motif", (PyCFunction)(void(*)(void))_wrap_fold_compound_ud_add_motif, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_ud_add_motif(fold_compound self, std::string motif, double motif_en, std::string name=\"\", unsigned int options=)\n"
		"\n"
		"\n"
		"Add an unstructured domain motif, e.g. for ligand binding.  \n"
		"\n"
		"This function adds a ligand binding motif and the associated binding free energy to the RNA.ud()\n"
		"attribute of a RNA.fold_compound(). The motif data will then be used in subsequent secondary\n"
		"structure predictions. Multiple calls to this function with different motifs append all additional\n"
		"data to a list of ligands, which all will be evaluated. Ligand motif data can be removed from the\n"
		"RNA.fold_compound() again using the RNA.fold_compound.ud_remove() function. The loop type parameter allows one\n"
		"to limit the ligand binding to particular loop type, such as the exterior loop, hairpin loops,\n"
		"internal loops, or multibranch loops.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"motif : const char *\n"
		"    The sequence motif the ligand binds to  \n"
		"motif_en : double\n"
		"    The binding free energy of the ligand in kcal/mol  \n"
		"motif_name : const char *\n"
		"    The name/id of the motif (may be `NULL`)  \n"
		"loop_type : unsigned int\n"
		"    The loop type the ligand binds to  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.UNSTRUCTURED_DOMAIN_EXT_LOOP, RNA.UNSTRUCTURED_DOMAIN_HP_LOOP,\n"
		"RNA.UNSTRUCTURED_DOMAIN_INT_LOOP, RNA.UNSTRUCTURED_DOMAIN_MB_LOOP,\n"
		"RNA.UNSTRUCTURED_DOMAIN_ALL_LOOPS, RNA.fold_compound.ud_remove()  \n"
		"\n"
		""},
	 { "fold_compound_ud_remove", _wrap_fold_compound_ud_remove, METH_O, "\n"
		"\n"
		"\n"
		"Remove ligand binding to unpaired stretches.  \n"
		"\n"
		"This function removes all ligand motifs that were bound to a RNA.fold_compound() using the\n"
		"RNA.fold_compound.ud_add_motif() function.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `ud_remove()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.ud_remove()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------  \n"
		"\n"
		""},
	 { "fold_compound_commands_apply", (PyCFunction)(void(*)(void))_wrap_fold_compound_commands_apply, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_commands_apply(fold_compound self, cmd commands, unsigned int options=) -> int\n"
		"\n"
		"\n"
		"Apply a list of commands to a RNA.fold_compound().  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `commands_apply()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.commands_apply()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"commands : RNA.cmd()\n"
		"    The commands to apply  \n"
		"options : unsigned int\n"
		"    Options to limit the type of commands read from the file  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The number of commands successfully applied  \n"
		"\n"
		""},
	 { "fold_compound_file_commands_apply", (PyCFunction)(void(*)(void))_wrap_fold_compound_file_commands_apply, METH_VARARGS|METH_KEYWORDS, "fold_compound_file_commands_apply(fold_compound self, std::string filename, unsigned int options=) -> int"},
	 { "fold_compound_rotational_symmetry_db", (PyCFunction)(void(*)(void))_wrap_fold_compound_rotational_symmetry_db, METH_VARARGS|METH_KEYWORDS, "\n"
		"\n"
		"\n"
		"Determine the order of rotational symmetry for a dot-bracket structure.  \n"
		"\n"
		"Given a (permutation of multiple) RNA strand(s) and a particular secondary structure in dot-bracket\n"
		"notation, compute the degree of rotational symmetry. In case there is only a single linear RNA\n"
		"strand, the structure always has degree 1, as there are no rotational symmetries due to the\n"
		"direction of the nucleic acid sequence and the fixed positions of 5' and 3' ends. However, for\n"
		"circular RNAs, rotational symmetries might arise if the sequence consists of a concatenation of\n"
		":math:`k` identical subsequences.  \n"
		"\n"
		"If the argument `positions` is not `NULL`, the function stores an array of string start positions\n"
		"for rotational shifts that map the string back onto itself. This array has length of order of\n"
		"rotational symmetry, i.e. the number returned by this function. The first element `positions`[0]\n"
		"always contains a shift value of `0` representing the trivial rotation.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `rotational_symmetry_db()` to objects of type\n"
		"    `fold_compound` (i.e. RNA.fold_compound()). Thus, the first argument must be omitted. In\n"
		"    contrast to our C-implementation, this function doesn't simply return the order of rotational\n"
		"    symmetry of the secondary structure, but returns the list `position` of cyclic permutation\n"
		"    shifts that result in a rotationally symmetric structure. The length of the list then determines\n"
		"    the order of rotational symmetry. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.rotational_symmetry_db()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"structure : const char *\n"
		"    The dot-bracket structure the degree of rotational symmetry is checked for  \n"
		"positions : unsigned int **\n"
		"    A pointer to an (undefined) list of alternative string start positions that lead to an identity\n"
		"    mapping (may be NULL)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"unsigned int  \n"
		"    The degree of rotational symmetry of the `structure` (0 in case of any errors)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.rotational_symmetry_db(), RNA.rotational_symmetry_pos(), RNA.rotational_symmetry_pos_num()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Do not forget to release the memory occupied by `positions` after a successful execution of this\n"
		"function.  \n"
		"\n"
		""},
	 { "fold_compound_neighbors", (PyCFunction)(void(*)(void))_wrap_fold_compound_neighbors, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_neighbors(fold_compound self, varArrayShort pt, unsigned int options=(4|8)) -> varArrayMove\n"
		"\n"
		"\n"
		"Generate neighbors of a secondary structure.  \n"
		"\n"
		"This function allows one to generate all structural neighbors (according to a particular move set)\n"
		"of an RNA secondary structure. The neighborhood is then returned as a list of transitions / moves\n"
		"required to transform the current structure into the actual neighbor.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `neighbors()` to objects of type\n"
		"    `fold_compound`. The optional parameter `options` defaults to RNA.MOVESET_DEFAULT if it is\n"
		"    omitted. See, e.g.   :py:meth:`RNA.fold_compound.neighbors()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : const short *\n"
		"    The pair table representation of the structure  \n"
		"options : unsigned int\n"
		"    Options to modify the behavior of this function, e.g. available move set  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.move() *  \n"
		"    Neighbors as a list of moves / transitions (the last element in the list has both of its fields\n"
		"    set to 0)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.neighbors_successive(), RNA.move_apply(), RNA.MOVESET_INSERTION, RNA.MOVESET_DELETION,\n"
		"RNA.MOVESET_SHIFT, RNA.MOVESET_DEFAULT  \n"
		"\n"
		""},
	 { "fold_compound_path", _wrap_fold_compound_path, METH_VARARGS, "\n"
		"fold_compound_path(fold_compound self, IntVector pt, unsigned int steps, unsigned int options=) -> MoveVector\n"
		"fold_compound_path(fold_compound self, varArrayShort pt, unsigned int steps, unsigned int options=) -> MoveVector\n"
		"\n"
		"\n"
		"Compute a path, store the final structure, and return a list of transition moves from the start to\n"
		"the final structure.  \n"
		"\n"
		"This function computes, given a start structure in pair table format, a transition path, updates the\n"
		"pair table to the final structure of the path. Finally, if not requested otherwise by using the\n"
		"RNA.PATH_NO_TRANSITION_OUTPUT flag in the `options` field, this function returns a list of\n"
		"individual transitions that lead from the start to the final structure if requested.  \n"
		"\n"
		"The currently available transition paths are  \n"
		"\n"
		"*   Steepest Descent / Gradient walk (flag: RNA.PATH_STEEPEST_DESCENT)  \n"
		"*   Random walk (flag: RNA.PATH_RANDOM)  \n"
		"\n"
		"The type of transitions must be set through the `options` parameter  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `path()` to objects of type `fold_compound`.\n"
		"    The optional parameter `options` defaults to RNA.PATH_DEFAULT if it is omitted. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.path()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : short *\n"
		"    The pair table containing the start structure. Used to update to the final structure after\n"
		"    execution of this function  \n"
		"options : unsigned int\n"
		"    Options to modify the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.move() *  \n"
		"    A list of transition moves (default), or NULL (if options & RNA.PATH_NO_TRANSITION_OUTPUT)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.path_gradient(), RNA.fold_compound.path_random(), RNA.ptable(), RNA.ptable_copy(),\n"
		"RNA.fold_compound()RNA.PATH_STEEPEST_DESCENT, RNA.PATH_RANDOM, RNA.MOVESET_DEFAULT,\n"
		"RNA.MOVESET_SHIFT, RNA.PATH_NO_TRANSITION_OUTPUT  \n"
		"\n"
		"Note\n"
		"----\n"
		"Since the result is written to the input structure you may want to use RNA.ptable_copy() before\n"
		"calling this function to keep the initial structure  \n"
		"\n"
		""},
	 { "fold_compound_path_gradient", _wrap_fold_compound_path_gradient, METH_VARARGS, "\n"
		"fold_compound_path_gradient(fold_compound self, IntVector pt, unsigned int options=) -> MoveVector\n"
		"fold_compound_path_gradient(fold_compound self, varArrayShort pt, unsigned int options=) -> MoveVector\n"
		"\n"
		"\n"
		"Compute a steepest descent / gradient path, store the final structure, and return a list of\n"
		"transition moves from the start to the final structure.  \n"
		"\n"
		"This function computes, given a start structure in pair table format, a steepest descent path,\n"
		"updates the pair table to the final structure of the path. Finally, if not requested otherwise by\n"
		"using the RNA.PATH_NO_TRANSITION_OUTPUT flag in the `options` field, this function returns a list\n"
		"of individual transitions that lead from the start to the final structure if requested.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `path_gradient()` to objects of type\n"
		"    `fold_compound`. The optional parameter `options` defaults to RNA.PATH_DEFAULT if it is\n"
		"    omitted. See, e.g.   :py:meth:`RNA.fold_compound.path_gradient()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : short *\n"
		"    The pair table containing the start structure. Used to update to the final structure after\n"
		"    execution of this function  \n"
		"options : unsigned int\n"
		"    Options to modify the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.move() *  \n"
		"    A list of transition moves (default), or NULL (if options & RNA.PATH_NO_TRANSITION_OUTPUT)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.path_random(), RNA.fold_compound.path(), RNA.ptable(), RNA.ptable_copy(),\n"
		"RNA.fold_compound()RNA.MOVESET_DEFAULT, RNA.MOVESET_SHIFT, RNA.PATH_NO_TRANSITION_OUTPUT  \n"
		"\n"
		"Note\n"
		"----\n"
		"Since the result is written to the input structure you may want to use RNA.ptable_copy() before\n"
		"calling this function to keep the initial structure  \n"
		"\n"
		""},
	 { "fold_compound_path_random", _wrap_fold_compound_path_random, METH_VARARGS, "\n"
		"fold_compound_path_random(fold_compound self, IntVector pt, unsigned int steps, unsigned int options=) -> MoveVector\n"
		"fold_compound_path_random(fold_compound self, varArrayShort pt, unsigned int steps, unsigned int options=) -> MoveVector\n"
		"\n"
		"\n"
		"Generate a random walk / path of a given length, store the final structure, and return a list of\n"
		"transition moves from the start to the final structure.  \n"
		"\n"
		"This function generates, given a start structure in pair table format, a random walk / path, updates\n"
		"the pair table to the final structure of the path. Finally, if not requested otherwise by using the\n"
		"RNA.PATH_NO_TRANSITION_OUTPUT flag in the `options` field, this function returns a list of\n"
		"individual transitions that lead from the start to the final structure if requested.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `path_gradient()` to objects of type\n"
		"    `fold_compound`. The optional parameter `options` defaults to RNA.PATH_DEFAULT if it is\n"
		"    omitted. See, e.g.   :py:meth:`RNA.fold_compound.path_random()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pt : short *\n"
		"    The pair table containing the start structure. Used to update to the final structure after\n"
		"    execution of this function  \n"
		"steps : unsigned int\n"
		"    The length of the path, i.e. the total number of transitions / moves  \n"
		"options : unsigned int\n"
		"    Options to modify the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.move() *  \n"
		"    A list of transition moves (default), or NULL (if options & RNA.PATH_NO_TRANSITION_OUTPUT)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.path_gradient(), RNA.fold_compound.path(), RNA.ptable(), RNA.ptable_copy(),\n"
		"RNA.fold_compound()RNA.MOVESET_DEFAULT, RNA.MOVESET_SHIFT, RNA.PATH_NO_TRANSITION_OUTPUT  \n"
		"\n"
		"Note\n"
		"----\n"
		"Since the result is written to the input structure you may want to use RNA.ptable_copy() before\n"
		"calling this function to keep the initial structure  \n"
		"\n"
		""},
	 { "fold_compound_path_findpath_saddle", (PyCFunction)(void(*)(void))_wrap_fold_compound_path_findpath_saddle, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_path_findpath_saddle(fold_compound self, std::string s1, std::string s2, int width=1, int maxE=INT_MAX) -> PyObject *\n"
		"\n"
		"\n"
		"Find energy of a saddle point between 2 structures (search only direct path).  \n"
		"\n"
		"This function uses an inplementation of the *findpath* algorithm    :cite:p:`flamm:2001`  for near-\n"
		"optimal direct refolding path prediction.  \n"
		"\n"
		"Model details, and energy parameters are used as provided via the parameter 'fc'. The\n"
		"RNA.fold_compound() does not require memory for any DP matrices, but requires all most basic init\n"
		"values as one would get from a call like this:  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `path_findpath_saddle()` to objects of type\n"
		"    `fold_compound`. The optional parameter `width` defaults to 1 if it is omitted, while the\n"
		"    optional parameter `maxE` defaults to INF. In case the function did not find a path with\n"
		"    :math:`E_{saddle} < E_{max}` the function returns a `NULL` object, i.e. `undef` for Perl and\n"
		"    `None` for Python. See, e.g.   :py:meth:`RNA.fold_compound.path_findpath_saddle()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s1 : const char *\n"
		"    The start structure in dot-bracket notation  \n"
		"s2 : const char *\n"
		"    The target structure in dot-bracket notation  \n"
		"width : int\n"
		"    A number specifying how many strutures are being kept at each step during the search  \n"
		"maxE : int\n"
		"    An upper bound for the saddle point energy in 10cal/mol  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    The saddle energy in 10cal/mol  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The argument `maxE` ( :math:`E_{max}`) enables one to specify an upper bound, or maximum free energy\n"
		"for the saddle point between the two input structures. If no path with :math:`E_{saddle} < E_{max}`\n"
		"is found, the function simply returns `maxE`  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.path_findpath_saddle(), RNA.fold_compound(), RNA.fold_compound(), RNA.path_findpath()  \n"
		"\n"
		""},
	 { "fold_compound_path_findpath", (PyCFunction)(void(*)(void))_wrap_fold_compound_path_findpath, METH_VARARGS|METH_KEYWORDS, "fold_compound_path_findpath(fold_compound self, std::string s1, std::string s2, int width=1, int maxE=INT_MAX-1) -> PathVector"},
	 { "fold_compound_path_direct", (PyCFunction)(void(*)(void))_wrap_fold_compound_path_direct, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_path_direct(fold_compound self, std::string s1, std::string s2, int maxE=INT_MAX-1, path_options options=None) -> PathVector\n"
		"\n"
		"\n"
		"Determine an optimal direct (re-)folding path between two secondary structures.  \n"
		"\n"
		"This function is similar to RNA.path_direct(), but allows to specify an *upper-bound* for the\n"
		"saddle point energy. The underlying algorithms will stop determining an (optimal) (re-)folding path,\n"
		"if none can be found that has a saddle point below the specified upper-bound threshold `maxE`.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as an overloaded method `path_direct()` to objects of type\n"
		"    `fold_compound`. The optional parameter `maxE` defaults to #INT_MAX - 1 if it is omitted, while\n"
		"    the optional parameter `options` defaults to `NULL`. In case the function did not find a path\n"
		"    with :math:`E_{saddle} < E_{max}` it returns an empty list. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.path_direct()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"s1 : const char *\n"
		"    The start structure in dot-bracket notation  \n"
		"s2 : const char *\n"
		"    The target structure in dot-bracket notation  \n"
		"maxE : int\n"
		"    Upper bound for the saddle point along the (re-)folding path  \n"
		"options : RNA.path_options()\n"
		"    An options data structure that specifies the path heuristic and corresponding settings (maybe\n"
		"    *NULL*)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.path() *  \n"
		"    An optimal (re-)folding path between the two input structures  \n"
		"\n"
		"Warnings\n"
		"--------\n"
		"The argument `maxE` enables one to specify an upper bound, or maximum free energy for the saddle\n"
		"point between the two input structures. If no path with :math:`E_{saddle} < E_{max}` is found, the\n"
		"function simply returns *NULL*  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.path_direct(), RNA.path_options_findpath(), RNA.path_options_free(),\n"
		"RNA.path_free()  \n"
		"\n"
		""},
	 { "fold_compound_heat_capacity", (PyCFunction)(void(*)(void))_wrap_fold_compound_heat_capacity, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_heat_capacity(fold_compound self, float T_min=0., float T_max=100., float T_increment=1., unsigned int mpoints=2) -> HeatCapacityVector\n"
		"\n"
		"\n"
		"Compute the specific heat for an RNA.  \n"
		"\n"
		"This function computes an RNAs specific heat in a given temperature range from the partition\n"
		"function by numeric differentiation. The result is returned as a list of pairs of temperature in C\n"
		"and specific heat in Kcal/(Mol*K).  \n"
		"\n"
		"Users can specify the temperature range for the computation from `T_min` to `T_max`, as well as the\n"
		"increment step size `T_increment`. The latter also determines how many times the partition function\n"
		"is computed. Finally, the parameter `mpoints` determines how smooth the curve should be. The\n"
		"algorithm itself fits a parabola to :math:`2 \\cdot mpoints + 1` data points to calculate 2nd\n"
		"derivatives. Increasing this parameter produces a smoother curve.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `heat_capacity()` to objects of type\n"
		"    `fold_compound`. If the optional function arguments `T_min`, `T_max`, `T_increment`, and\n"
		"    `mpoints` are omitted, they default to 0.0, 100.0, 1.0 and 2, respectively. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.heat_capacity()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"T_min : float\n"
		"    Lowest temperature in C  \n"
		"T_max : float\n"
		"    Highest temperature in C  \n"
		"T_increment : float\n"
		"    Stepsize for temperature incrementation in C (a reasonable choice might be 1C)  \n"
		"mpoints : unsigned int\n"
		"    The number of interpolation points to calculate 2nd derivative (a reasonable choice might be 2,\n"
		"    min: 1, max: 100)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.heat_capacity() *  \n"
		"    A list of pairs of temperatures and corresponding heat capacity or *NULL* upon any failure. The\n"
		"    last entry of the list is indicated by a **temperature** field set to a value smaller than\n"
		"    `T_min`  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.heat_capacity_cb(), RNA.heat_capacity(), RNA.heat_capacity()  \n"
		"\n"
		""},
	 { "fold_compound_add_auxdata", (PyCFunction)(void(*)(void))_wrap_fold_compound_add_auxdata, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_add_auxdata(fold_compound self, PyObject * data, PyObject * PyFuncOrNone=Py_None) -> PyObject *\n"
		"\n"
		"\n"
		"Add auxiliary data to the RNA.fold_compound().  \n"
		"\n"
		"This function allows one to bind arbitrary data to a RNA.fold_compound() which may later on be used\n"
		"by one of the callback functions, e.g. RNA.recursion_status(). To allow for proper cleanup of the\n"
		"memory occupied by this auxiliary data, the user may also provide a pointer to a cleanup function\n"
		"that free's the corresponding memory. This function will be called automatically when the\n"
		"RNA.fold_compound() is free'd with RNA.fold_compound_free().  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"data : void *\n"
		"    A pointer to an arbitrary data structure  \n"
		"f : RNA.auxdata_free\n"
		"    A pointer to function that free's memory occupied by the arbitrary data (May be NULL)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.auxdata_free()  \n"
		"\n"
		"Note\n"
		"----\n"
		"Before attaching the arbitrary data pointer, this function will call the RNA.auxdata_free() on\n"
		"any pre-existing data that is already attached.  \n"
		"\n"
		""},
	 { "fold_compound_add_callback", (PyCFunction)(void(*)(void))_wrap_fold_compound_add_callback, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_add_callback(fold_compound self, PyObject * PyFunc) -> PyObject *\n"
		"\n"
		"\n"
		"Add a recursion status callback to the RNA.fold_compound().  \n"
		"\n"
		"Binding a recursion status callback function to a RNA.fold_compound() allows one to perform\n"
		"arbitrary operations just before, or after an actual recursive computations, e.g. MFE prediction, is\n"
		"performed by the RNAlib. The callback function will be provided with a pointer to its\n"
		"RNA.fold_compound(), and a status message. Hence, it has complete access to all variables that\n"
		"incluence the recursive computations.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"f : RNA.recursion_status\n"
		"    The pointer to the recursion status callback function  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.recursion_status(), RNA.fold_compound(), RNA.STATUS_MFE_PRE, RNA.STATUS_MFE_POST,\n"
		"RNA.STATUS_PF_PRE, RNA.STATUS_PF_POST  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_data", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_data, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_data(fold_compound self, PyObject * data, PyObject * callback=Py_None) -> int\n"
		"\n"
		"\n"
		"Add an auxiliary data structure for the generic soft constraints callback function.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add_data()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.sc_add_data()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"data : void *\n"
		"    A pointer to the data structure that holds required data for function 'f'  \n"
		"free_data : RNA.auxdata_free\n"
		"    A pointer to a function that free's the memory occupied by `data` (Maybe NULL)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful binding the data (and free-function), 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_add(), RNA.fold_compound.sc_add_exp(), RNA.fold_compound.sc_add_bt()  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_f", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_f, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_f(fold_compound self, PyObject * callback) -> int\n"
		"\n"
		"\n"
		"Bind a function pointer for generic soft constraint feature (MFE version).  \n"
		"\n"
		"This function allows one to easily bind a function pointer and corresponding data structure to the\n"
		"soft constraint part RNA.sc() of the RNA.fold_compound(). The function for evaluating the generic\n"
		"soft constraint feature has to return a pseudo free energy :math:`\\hat{E}` in :math:`dacal/mol`,\n"
		"where :math:`1 dacal/mol = 10 cal/mol`.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_add()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"f : RNA.sc\n"
		"    A pointer to the function that evaluates the generic soft constraint feature  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful binding the callback function, 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_add_data(), RNA.fold_compound.sc_add_bt(), RNA.fold_compound.sc_add_exp()  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_bt", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_bt, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_bt(fold_compound self, PyObject * PyFunc) -> int\n"
		"\n"
		"\n"
		"Bind a backtracking function pointer for generic soft constraint feature.  \n"
		"\n"
		"This function allows one to easily bind a function pointer to the soft constraint part RNA.sc() of\n"
		"the RNA.fold_compound(). The provided function should be used for backtracking purposes in loop\n"
		"regions that were altered via the generic soft constraint feature. It has to return an array of\n"
		"RNA.basepair() data structures, were the last element in the list is indicated by a value of -1 in\n"
		"it's i position.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add_bt()` to objects of type `fold_compound`. See, e.g.\n"
		"    :py:meth:`RNA.fold_compound.sc_add_bt()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"f : RNA.sc_bt\n"
		"    A pointer to the function that returns additional base pairs  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful binding the callback function, 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_add_data(), RNA.fold_compound.sc_add(), RNA.fold_compound.sc_add_exp()  \n"
		"\n"
		""},
	 { "fold_compound_sc_add_exp_f", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_add_exp_f, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_sc_add_exp_f(fold_compound self, PyObject * PyFunc) -> int\n"
		"\n"
		"\n"
		"Bind a function pointer for generic soft constraint feature (PF version).  \n"
		"\n"
		"This function allows one to easily bind a function pointer and corresponding data structure to the\n"
		"soft constraint part RNA.sc() of the RNA.fold_compound(). The function for evaluating the generic\n"
		"soft constraint feature has to return a pseudo free energy :math:`\\hat{E}` as Boltzmann factor,\n"
		"i.e. :math:`exp(- \\hat{E} / kT)`. The required unit for :math:`E` is :math:`cal/mol`.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `sc_add_exp()` to objects of type `fold_compound`. See,\n"
		"    e.g.    :py:meth:`RNA.fold_compound.sc_add_exp()` in the :doc:`/api_python` .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"exp : RNA.sc_exp\n"
		"    A pointer to the function that evaluates the generic soft constraint feature  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Non-zero on successful binding the callback function, 0 otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.sc_add_bt(), RNA.fold_compound.sc_add(), RNA.fold_compound.sc_add_data()  \n"
		"\n"
		""},
	 { "fold_compound_ud_set_data", (PyCFunction)(void(*)(void))_wrap_fold_compound_ud_set_data, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_ud_set_data(fold_compound self, PyObject * data, PyObject * free_cb=Py_None) -> PyObject *\n"
		"\n"
		"\n"
		"Attach an auxiliary data structure.  \n"
		"\n"
		"This function binds an arbitrary, auxiliary data structure for user-implemented ligand binding. The\n"
		"optional callback `free_cb` will be passed the bound data structure whenever the\n"
		"RNA.fold_compound() is removed from memory to avoid memory leaks.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `ud_set_data()` to objects of type `fold_compound`. See,\n"
		"    e.g.   :py:meth:`RNA.fold_compound.ud_set_data()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"data : void *\n"
		"    A pointer to the auxiliary data structure  \n"
		"free_cb : RNA.auxdata_free\n"
		"    A pointer to a callback function that free's memory occupied by `data`  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.ud_set_prod_rule_cb(), RNA.fold_compound.ud_set_exp_prod_rule_cb(),\n"
		"RNA.fold_compound.ud_remove()  \n"
		"\n"
		""},
	 { "fold_compound_ud_set_prod_rule_cb", (PyCFunction)(void(*)(void))_wrap_fold_compound_ud_set_prod_rule_cb, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_ud_set_prod_rule_cb(fold_compound self, PyObject * prod_cb, PyObject * eval_cb) -> PyObject *\n"
		"\n"
		"\n"
		"Attach production rule callbacks for free energies computations.  \n"
		"\n"
		"Use this function to bind a user-implemented grammar extension for unstructured domains.  \n"
		"\n"
		"The callback `e_cb` needs to evaluate the free energy contribution :math:`f(i,j)` of the unpaired\n"
		"segment :math:`[i,j]`. It will be executed in each of the regular secondary structure production\n"
		"rules. Whenever the callback is passed the RNA.UNSTRUCTURED_DOMAIN_MOTIF flag via its `loop_type`\n"
		"parameter the contribution of any ligand that consecutively binds from position :math:`i` to\n"
		":math:`j` (the white box) is requested. Otherwise, the callback usually performs a lookup in the\n"
		"precomputed `B` matrices. Which `B` matrix is addressed will be indicated by the flags\n"
		"RNA.UNSTRUCTURED_DOMAIN_EXT_LOOP,\n"
		"RNA.UNSTRUCTURED_DOMAIN_HP_LOOPRNA.UNSTRUCTURED_DOMAIN_INT_LOOP, and\n"
		"RNA.UNSTRUCTURED_DOMAIN_MB_LOOP. As their names already imply, they specify exterior loops (`F`\n"
		"production rule), hairpin loops and internal loops (`C` production rule), and multibranch loops (`M`\n"
		"and `M1` production rule).  \n"
		"\n"
		"\n"
		"The `pre_cb` callback will be executed as a pre-processing step right before the regular secondary\n"
		"structure rules. Usually one would use this callback to fill the dynamic programming matrices `U`\n"
		"and preparations of the auxiliary data structure RNA.unstructured_domain().data  \n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `ud_set_prod_rule_cb()` to objects of type `fold_compound`.\n"
		"    See, e.g.   :py:meth:`RNA.fold_compound.ud_set_prod_rule_cb()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pre_cb : RNA.ud_production\n"
		"    A pointer to a callback function for the `B` production rule  \n"
		"e_cb : RNA.ud\n"
		"    A pointer to a callback function for free energy evaluation  \n"
		"\n"
		""},
	 { "fold_compound_ud_set_exp_prod_rule_cb", (PyCFunction)(void(*)(void))_wrap_fold_compound_ud_set_exp_prod_rule_cb, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_ud_set_exp_prod_rule_cb(fold_compound self, PyObject * prod_cb, PyObject * eval_cb) -> PyObject *\n"
		"\n"
		"\n"
		"Attach production rule for partition function.  \n"
		"\n"
		"This function is the partition function companion of RNA.fold_compound.ud_set_prod_rule_cb().  \n"
		"\n"
		"Use it to bind callbacks to (i) fill the `U` production rule dynamic programming matrices and/or\n"
		"prepare the RNA.unstructured_domain().data, and (ii) provide a callback to retrieve partition\n"
		"functions for subsegments :math:`[i,j]`.  \n"
		"\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `ud_set_exp_prod_rule_cb()` to objects of type\n"
		"    `fold_compound`. See, e.g.   :py:meth:`RNA.fold_compound.ud_set_exp_prod_rule_cb()` in the\n"
		"    :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"pre_cb : RNA.ud_exp_production\n"
		"    A pointer to a callback function for the `B` production rule  \n"
		"exp_e_cb : RNA.ud_exp\n"
		"    A pointer to a callback function that retrieves the partition function for a segment\n"
		"    :math:`[i,j]` that may be bound by one or more ligands.  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.ud_set_prod_rule_cb()  \n"
		"\n"
		""},
	 { "fold_compound_ud_set_prob_cb", (PyCFunction)(void(*)(void))_wrap_fold_compound_ud_set_prob_cb, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_ud_set_prob_cb(fold_compound self, PyObject * setter_cb, PyObject * getter_cb) -> PyObject *\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `ud_set_prob_cb()` to objects of type `fold_compound`. See,\n"
		"    e.g.   :py:meth:`RNA.fold_compound.ud_set_prob_cb()` in the :doc:`/api_python`.  \n"
		"\n"
		""},
	 { "fold_compound_subopt_cb", (PyCFunction)(void(*)(void))_wrap_fold_compound_subopt_cb, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_subopt_cb(fold_compound self, int delta, PyObject * PyFunc, PyObject * data=Py_None) -> PyObject *\n"
		"\n"
		"\n"
		"Generate suboptimal structures within an energy band arround the MFE.  \n"
		"\n"
		"This is the most generic implementation of the suboptimal structure generator according to\n"
		":cite:t:`wuchty:1999` . Identical to RNA.fold_compound.subopt(), it computes all secondary structures within an\n"
		"energy band `delta` arround the MFE. However, this function does not print the resulting structures\n"
		"and their corresponding free energies to a file pointer, or returns them as a list. Instead, it\n"
		"calls a user-provided callback function which it passes the structure in dot-bracket format, the\n"
		"corresponding free energy in kcal/mol, and a user-provided data structure each time a structure was\n"
		"backtracked successfully. This function indicates the final output, i.e. the end of the backtracking\n"
		"procedure by passing NULL instead of an actual dot-bracket string to the callback.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method **subopt_cb()** to objects of type `fold_compound`. See,\n"
		"    e.g.   :py:meth:`RNA.fold_compound.subopt_cb()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"delta : int\n"
		"    Energy band arround the MFE in 10cal/mol, i.e. deka-calories  \n"
		"cb : RNA.subopt_result\n"
		"    Pointer to a callback function that handles the backtracked structure and its free energy in\n"
		"    kcal/mol  \n"
		"data : void *\n"
		"    Pointer to some data structure that is passed along to the callback  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.subopt_result, RNA.fold_compound.subopt(), RNA.fold_compound.subopt_zuker()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function requires all multibranch loop DP matrices for unique multibranch loop backtracing.\n"
		"Therefore, the supplied RNA.fold_compound()`fc` (argument 1) must be initialized with\n"
		"RNA.md().uniq_ML = 1, for instance like this:  \n"
		"\n"
		""},
	 { "fold_compound_pbacktrack", _wrap_fold_compound_pbacktrack, METH_VARARGS, "\n"
		"fold_compound_pbacktrack(fold_compound self) -> char\n"
		"fold_compound_pbacktrack(fold_compound self, unsigned int num_samples, unsigned int options=) -> StringVector\n"
		"fold_compound_pbacktrack(fold_compound self, unsigned int num_samples, pbacktrack_mem nr_memory, unsigned int options=) -> StringVector\n"
		"fold_compound_pbacktrack(self, num_samples, PyFunc, data=Py_None, options=0) -> unsigned int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num_samples: unsigned int\n"
		"PyFunc: PyObject *\n"
		"data: PyObject *\n"
		"options: unsigned int\n"
		"\n"
		"fold_compound_pbacktrack(self, num_samples, PyFunc, data, nr_memory, options=0) -> unsigned int\n"
		"\n"
		"Parameters\n"
		"----------\n"
		"num_samples: unsigned int\n"
		"PyFunc: PyObject *\n"
		"data: PyObject *\n"
		"nr_memory: vrna_pbacktrack_mem_t *\n"
		"options: unsigned int\n"
		"\n"
		"\n"
		"\n"
		"Sample a secondary structure from the Boltzmann ensemble according its probability.  \n"
		"\n"
		"Perform a probabilistic (stochastic) backtracing in the partition function DP arrays to obtain a\n"
		"secondary structure.  \n"
		"\n"
		"The structure :math:`s` with free energy :math:`E(s)` is picked from the Boltzmann distributed\n"
		"ensemble according to its probability  \n"
		"\n"
		".. math::\n"
		"\n"
		"  p(s) = \\frac{exp(-E(s) / kT)}{Z}  \n"
		"\n"
		"with partition function :math:`Z = \\sum_{s} exp(-E(s) / kT)`, Boltzmann constant :math:`k` and\n"
		"thermodynamic temperature :math:`T`.  \n"
		"\n"
		"**Precondition**\n"
		"    Unique multiloop decomposition has to be active upon creation of `fc` with RNA.fold_compound()\n"
		"    or similar. This can be done easily by passing RNA.fold_compound() a model details parameter\n"
		"    with RNA.md().uniq_ML = 1.  RNA.fold_compound.pf() has to be called first to fill the partition\n"
		"    function\n"
		"    matrices  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `pbacktrack()` to objects of type\n"
		"    `fold_compound`. See, e.g.    :py:meth:`RNA.fold_compound.pbacktrack()` in the\n"
		"    :doc:`/api_python`  and the    :ref:`examples/python:boltzmann sampling` Python examples .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A sampled secondary structure in dot-bracket notation (or NULL on error)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.pbacktrack5(), RNA.pbacktrack_num, RNA.pbacktrack_cb()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is polymorphic. It accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE, and\n"
		"RNA.FC_TYPE_COMPARATIVE.  \n"
		"\n"
		""},
	 { "fold_compound_pbacktrack5", _wrap_fold_compound_pbacktrack5, METH_VARARGS, "\n"
		"fold_compound_pbacktrack5(fold_compound self, unsigned int length) -> char\n"
		"fold_compound_pbacktrack5(fold_compound self, unsigned int num_samples, unsigned int length, unsigned int options=) -> StringVector\n"
		"fold_compound_pbacktrack5(fold_compound self, unsigned int num_samples, unsigned int length, pbacktrack_mem nr_memory, unsigned int options=) -> StringVector\n"
		"fold_compound_pbacktrack5(fold_compound self, unsigned int num_samples, unsigned int length, PyObject * PyFunc, PyObject * data=Py_None, unsigned int options=0) -> unsigned int\n"
		"fold_compound_pbacktrack5(fold_compound self, unsigned int num_samples, unsigned int length, PyObject * PyFunc, PyObject * data, pbacktrack_mem nr_memory, unsigned int options=0) -> unsigned int\n"
		"\n"
		"\n"
		"Sample a secondary structure of a subsequence from the Boltzmann ensemble according its probability.  \n"
		"\n"
		"Perform a probabilistic (stochastic) backtracing in the partition function DP arrays to obtain a\n"
		"secondary structure. The parameter `length` specifies the length of the substructure starting from\n"
		"the 5' end.  \n"
		"\n"
		"The structure :math:`s` with free energy :math:`E(s)` is picked from the Boltzmann distributed\n"
		"ensemble according to its probability  \n"
		"\n"
		".. math::\n"
		"\n"
		"  p(s) = \\frac{exp(-E(s) / kT)}{Z}  \n"
		"\n"
		"with partition function :math:`Z = \\sum_{s} exp(-E(s) / kT)`, Boltzmann constant :math:`k` and\n"
		"thermodynamic temperature :math:`T`.  \n"
		"\n"
		"**Precondition**\n"
		"    Unique multiloop decomposition has to be active upon creation of `fc` with RNA.fold_compound()\n"
		"    or similar. This can be done easily by passing RNA.fold_compound() a model details parameter\n"
		"    with RNA.md().uniq_ML = 1.  RNA.fold_compound.pf() has to be called first to fill the partition\n"
		"    function\n"
		"    matrices  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `pbacktrack5()` to objects of type\n"
		"    `fold_compound`. See, e.g.    :py:meth:`RNA.fold_compound.pbacktrack5()` in the\n"
		"    :doc:`/api_python`  and the    :ref:`examples/python:boltzmann sampling` Python examples .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"length : unsigned int\n"
		"    The length of the subsequence to consider (starting with 5' end)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A sampled secondary structure in dot-bracket notation (or NULL on error)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.pbacktrack5_num(), RNA.pbacktrack5_cb(), RNA.fold_compound.pbacktrack()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is polymorphic. It accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE, and\n"
		"RNA.FC_TYPE_COMPARATIVE.  \n"
		"\n"
		""},
	 { "fold_compound_pbacktrack_sub", _wrap_fold_compound_pbacktrack_sub, METH_VARARGS, "\n"
		"fold_compound_pbacktrack_sub(fold_compound self, unsigned int start, unsigned int end) -> char\n"
		"fold_compound_pbacktrack_sub(fold_compound self, unsigned int num_samples, unsigned int start, unsigned int end, unsigned int options=) -> StringVector\n"
		"fold_compound_pbacktrack_sub(fold_compound self, unsigned int num_samples, unsigned int start, unsigned int end, pbacktrack_mem nr_memory, unsigned int options=) -> StringVector\n"
		"fold_compound_pbacktrack_sub(fold_compound self, unsigned int num_samples, unsigned int start, unsigned int end, PyObject * PyFunc, PyObject * data=Py_None, unsigned int options=0) -> unsigned int\n"
		"fold_compound_pbacktrack_sub(fold_compound self, unsigned int num_samples, unsigned int start, unsigned int end, PyObject * PyFunc, PyObject * data, pbacktrack_mem nr_memory, unsigned int options=0) -> unsigned int\n"
		"\n"
		"\n"
		"Sample a secondary structure of a subsequence from the Boltzmann ensemble according its probability.  \n"
		"\n"
		"Perform a probabilistic (stochastic) backtracing in the partition function DP arrays to obtain a\n"
		"secondary structure. The parameters `start` and `end` specify the interval :math:`[start:end]` of\n"
		"the subsequence with :math:`1 \\leq start < end \\leq n` for sequence length :math:`n`, the\n"
		"structure :math:`s_{start,end}` should be drawn from.  \n"
		"\n"
		"The resulting substructure :math:`s_{start,end}` with free energy :math:`E(s_{start, end})` is\n"
		"picked from the Boltzmann distributed sub ensemble of all structures within the interval\n"
		":math:`[start:end]` according to its probability  \n"
		"\n"
		".. math::\n"
		"\n"
		"  p(s_{start,end}) = \\frac{exp(-E(s_{start,end}) / kT)}{Z_{start,end}}  \n"
		"\n"
		"with partition function :math:`Z_{start,end} = \\sum_{s_{start,end}} exp(-E(s_{start,end}) / kT)`,\n"
		"Boltzmann constant :math:`k` and thermodynamic temperature :math:`T`.  \n"
		"\n"
		"**Precondition**\n"
		"    Unique multiloop decomposition has to be active upon creation of `fc` with RNA.fold_compound()\n"
		"    or similar. This can be done easily by passing RNA.fold_compound() a model details parameter\n"
		"    with RNA.md().uniq_ML = 1.  RNA.fold_compound.pf() has to be called first to fill the partition\n"
		"    function\n"
		"    matrices  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `pbacktrack_sub()` to objects of type\n"
		"    *fold_compound*. See, e.g.    :py:meth:`RNA.fold_compound.pbacktrack_sub()` in the\n"
		"    :doc:`/api_python`  and the    :ref:`examples/python:boltzmann sampling` Python examples .  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"start : unsigned int\n"
		"    The start of the subsequence to consider, i.e. 5'-end position(1-based)  \n"
		"end : unsigned int\n"
		"    The end of the subsequence to consider, i.e. 3'-end position (1-based)  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"char *  \n"
		"    A sampled secondary structure in dot-bracket notation (or NULL on error)  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.pbacktrack_sub_num(), RNA.pbacktrack_sub_cb(), RNA.fold_compound.pbacktrack()  \n"
		"\n"
		"Note\n"
		"----\n"
		"This function is polymorphic. It accepts RNA.fold_compound() of type RNA.FC_TYPE_SINGLE, and\n"
		"RNA.FC_TYPE_COMPARATIVE.  \n"
		"\n"
		""},
	 { "fold_compound_mfe_window_cb", (PyCFunction)(void(*)(void))_wrap_fold_compound_mfe_window_cb, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_mfe_window_cb(fold_compound self, PyObject * PyFunc, PyObject * data=Py_None) -> float\n"
		"\n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as overloaded method `mfe_window_cb()` to objects of type `The Fold\n"
		"    Compound`. The parameter `data` has default value of `NULL` and can be omitted. See e.g.\n"
		"    :py:meth:`RNA.fold_compound.mfe_window_cb()` in the :doc:`/api_python`.  \n"
		"\n"
		""},
	 { "fold_compound_mfe_window_zscore_cb", (PyCFunction)(void(*)(void))_wrap_fold_compound_mfe_window_zscore_cb, METH_VARARGS|METH_KEYWORDS, "fold_compound_mfe_window_zscore_cb(fold_compound self, double min_z, PyObject * PyFunc, PyObject * data=Py_None) -> float"},
	 { "fold_compound_probs_window", (PyCFunction)(void(*)(void))_wrap_fold_compound_probs_window, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_probs_window(fold_compound self, int ulength, unsigned int options, PyObject * PyFunc, PyObject * data=Py_None) -> int\n"
		"\n"
		"\n"
		"Compute various equilibrium probabilities under a sliding window approach.  \n"
		"\n"
		"This function applies a sliding window scan for the sequence provided with the argument `fc` and\n"
		"reports back equilibrium probabilities through the callback function `cb`. The data reported to the\n"
		"callback depends on the `options` flag.  \n"
		"\n"
		"#### Options:  \n"
		"Note\n"
		"----\n"
		"The parameter `ulength` only affects computation and resulting data if unpaired probability\n"
		"computations are requested through the `options` flag.  \n"
		"\n"
		"*   RNA.PROBS_WINDOW_BPP -   Trigger base pairing probabilities.  \n"
		"*   RNA.PROBS_WINDOW_UP -   Trigger unpaired probabilities.  \n"
		"*   RNA.PROBS_WINDOW_UP_SPLIT -   Trigger detailed unpaired probabilities split up into different\n"
		"    loop type contexts.  \n"
		"\n"
		"Options may be OR-ed together  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ulength : int\n"
		"    The maximal length of an unpaired segment (only for unpaired probability computations)  \n"
		"cb : RNA.probs_window\n"
		"    The callback function which collects the pair probability data for further processing  \n"
		"data : void *\n"
		"    Some arbitrary data structure that is passed to the callback `cb`  \n"
		"options : unsigned int\n"
		"    Option flags to control the behavior of this function  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    0 on failure, non-zero on success  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.pfl_fold_cb(), RNA.pfl_fold_up_cb()  \n"
		"\n"
		""},
	 { "fold_compound_heat_capacity_cb", (PyCFunction)(void(*)(void))_wrap_fold_compound_heat_capacity_cb, METH_VARARGS|METH_KEYWORDS, "\n"
		"fold_compound_heat_capacity_cb(fold_compound self, float T_min, float T_max, float T_increment, unsigned int mpoints, PyObject * PyFunc, PyObject * data=Py_None) -> PyObject *\n"
		"\n"
		"\n"
		"Compute the specific heat for an RNA (callback variant).  \n"
		"\n"
		"Similar to RNA.fold_compound.heat_capacity(), this function computes an RNAs specific heat in a given temperature\n"
		"range from the partition function by numeric differentiation. Instead of returning a list of\n"
		"temperature/specific heat pairs, however, this function returns the individual results through a\n"
		"callback mechanism. The provided function will be called for each result and passed the\n"
		"corresponding temperature and specific heat values along with the arbitrary data as provided through\n"
		"the `data` pointer argument.  \n"
		"\n"
		"Users can specify the temperature range for the computation from `T_min` to `T_max`, as well as the\n"
		"increment step size `T_increment`. The latter also determines how many times the partition function\n"
		"is computed. Finally, the parameter `mpoints` determines how smooth the curve should be. The\n"
		"algorithm itself fits a parabola to :math:`2 \\cdot mpoints + 1` data points to calculate 2nd\n"
		"derivatives. Increasing this parameter produces a smoother curve.  \n"
		"\n"
		".. admonition:: SWIG Wrapper Notes\n"
		"\n"
		"    This function is attached as method `heat_capacity_cb()` to objects of type `fold_compound`.\n"
		"    See, e.g.   :py:meth:`RNA.fold_compound.heat_capacity_cb()` in the :doc:`/api_python`.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"T_min : float\n"
		"    Lowest temperature in C  \n"
		"T_max : float\n"
		"    Highest temperature in C  \n"
		"T_increment : float\n"
		"    Stepsize for temperature incrementation in C (a reasonable choice might be 1C)  \n"
		"mpoints : unsigned int\n"
		"    The number of interpolation points to calculate 2nd derivative (a reasonable choice might be 2,\n"
		"    min: 1, max: 100)  \n"
		"cb : RNA.heat_capacity\n"
		"    The user-defined callback function that receives the individual results  \n"
		"data : void *\n"
		"    An arbitrary data structure that will be passed to the callback in conjunction with the results  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"int  \n"
		"    Returns 0 upon failure, and non-zero otherwise  \n"
		"\n"
		"See Also\n"
		"--------\n"
		"RNA.fold_compound.heat_capacity(), RNA.heat_capacity  \n"
		"\n"
		""},
	 { "fold_compound_move_neighbor_diff", _wrap_fold_compound_move_neighbor_diff, METH_VARARGS, "\n"
		"fold_compound_move_neighbor_diff(self, pt, move, options=(4|8)) -> varArrayMove\n"
		"fold_compound_move_neighbor_diff(fold_compound self, varArrayShort pt, move move, PyObject * PyFunc, PyObject * data=Py_None, unsigned int options=(4|8)) -> int\n"
		"\n"
		"\n"
		"Apply a move to a secondary structure and indicate which neighbors have changed consequentially.  \n"
		"\n"
		"Similar to RNA.move_neighbor_diff_cb(), this function applies a move to a secondary structure and\n"
		"reports back the neighbors of the current structure become affected by this move. Instead of\n"
		"executing a callback for each of the affected neighbors, this function compiles two lists of\n"
		"neighbor moves, one that is returned and consists of all moves that are novel or may have changed in\n"
		"energy, and a second, `invalid_moves`, that consists of all the neighbor moves that become invalid,\n"
		"respectively.  \n"
		"\n"
		"Parameters\n"
		"----------\n"
		"ptable : short *\n"
		"    The current structure as pair table  \n"
		"move : RNA.move()\n"
		"    The move to apply  \n"
		"invalid_moves : RNA.move() **\n"
		"    The address of a move list where the function stores those moves that become invalid  \n"
		"options : unsigned int\n"
		"    Options to modify the behavior of this function, .e.g available move set  \n"
		"\n"
		"Returns\n"
		"-------\n"
		"RNA.move() *  \n"
		"    A list of moves that might have changed in energy or are novel compared to the structure before\n"
		"    application of the move  \n"
		"\n"
		""},
	 { "fold_compound_sc_multi_cb_add", (PyCFunction)(void(*)(void))_wrap_fold_compound_sc_multi_cb_add, METH_VARARGS|METH_KEYWORDS, "fold_compound_sc_multi_cb_add(fold_compound self, PyObject * f, PyObject * f_exp=Py_None, PyObject * data=Py_None, PyObject * data_prepare=Py_None, PyObject * data_free=Py_None, unsigned int decomp_type=0) -> unsigned int"},
	 { "fold_compound_type_get", _wrap_fold_compound_type_get, METH_O, NULL},
	 { "fold_compound_sequence_get", _wrap_fold_compound_sequence_get, METH_O, NULL},
	 { "fold_compound_length_get", _wrap_fold_compound_length_get, METH_O, NULL},
	 { "fold_compound_strands_get", _wrap_fold_compound_strands_get, METH_O, NULL},
	 { "fold_compound_params_get", _wrap_fold_compound_params_get, METH_O, NULL},
	 { "fold_compound_exp_params_get", _wrap_fold_compound_exp_params_get, METH_O, NULL},
	 { "fold_compound_matrices_get", _wrap_fold_compound_matrices_get, METH_O, NULL},
	 { "fold_compound_exp_matrices_get", _wrap_fold_compound_exp_matrices_get, METH_O, NULL},
	 { "fold_compound_hc_get", _wrap_fold_compound_hc_get, METH_O, NULL},
	 { "fold_compound_strand_number_get", _wrap_fold_compound_strand_number_get, METH_O, NULL},
	 { "fold_compound_strand_order_get", _wrap_fold_compound_strand_order_get, METH_O, NULL},
	 { "fold_compound_strand_start_get", _wrap_fold_compound_strand_start_get, METH_O, NULL},
	 { "fold_compound_strand_end_get", _wrap_fold_compound_strand_end_get, METH_O, NULL},
	 { "fold_compound_iindx_get", _wrap_fold_compound_iindx_get, METH_O, NULL},
	 { "fold_compound_jindx_get", _wrap_fold_compound_jindx_get, METH_O, NULL},
	 { "fold_compound_sequence_encoding_get", _wrap_fold_compound_sequence_encoding_get, METH_O, NULL},
	 { "fold_compound_sequence_encoding2_get", _wrap_fold_compound_sequence_encoding2_get, METH_O, NULL},
	 { "new_fold_compound", _wrap_new_fold_compound, METH_VARARGS, "\n"
		"fold_compound(char const * sequence, md md=None, unsigned int options=)\n"
		"fold_compound(StringVector alignment, md md=None, unsigned int options=)\n"
		"new_fold_compound(char const * sequence, char * s1, char * s2, md md=None, unsigned int options=) -> fold_compound\n"
		""},
	 { "delete_fold_compound", _wrap_delete_fold_compound, METH_O, NULL},
	 { "fold_compound___str__", _wrap_fold_compound___str__, METH_O, NULL},
	 { "fold_compound_swigregister", fold_compound_swigregister, METH_O, NULL},
	 { "fold_compound_swiginit", fold_compound_swiginit, METH_VARARGS, NULL},
	 { "mx_mfe_type_get", _wrap_mx_mfe_type_get, METH_O, NULL},
	 { "mx_mfe_length_get", _wrap_mx_mfe_length_get, METH_O, NULL},
	 { "mx_mfe_strands_get", _wrap_mx_mfe_strands_get, METH_O, NULL},
	 { "mx_mfe_f5_get", _wrap_mx_mfe_f5_get, METH_O, NULL},
	 { "mx_mfe_f3_get", _wrap_mx_mfe_f3_get, METH_O, NULL},
	 { "mx_mfe_c_get", _wrap_mx_mfe_c_get, METH_O, NULL},
	 { "mx_mfe_fML_get", _wrap_mx_mfe_fML_get, METH_O, NULL},
	 { "mx_mfe_fM1_get", _wrap_mx_mfe_fM1_get, METH_O, NULL},
	 { "mx_mfe_fM2_get", _wrap_mx_mfe_fM2_get, METH_O, NULL},
	 { "mx_mfe_Fc_get", _wrap_mx_mfe_Fc_get, METH_O, NULL},
	 { "mx_mfe_FcH_get", _wrap_mx_mfe_FcH_get, METH_O, NULL},
	 { "mx_mfe_FcI_get", _wrap_mx_mfe_FcI_get, METH_O, NULL},
	 { "mx_mfe_FcM_get", _wrap_mx_mfe_FcM_get, METH_O, NULL},
	 { "new_mx_mfe", _wrap_new_mx_mfe, METH_NOARGS, NULL},
	 { "delete_mx_mfe", _wrap_delete_mx_mfe, METH_O, NULL},
	 { "mx_mfe_swigregister", mx_mfe_swigregister, METH_O, NULL},
	 { "mx_mfe_swiginit", mx_mfe_swiginit, METH_VARARGS, NULL},
	 { "mx_pf_type_get", _wrap_mx_pf_type_get, METH_O, NULL},
	 { "mx_pf_length_get", _wrap_mx_pf_length_get, METH_O, NULL},
	 { "mx_pf_scale_get", _wrap_mx_pf_scale_get, METH_O, NULL},
	 { "mx_pf_expMLbase_get", _wrap_mx_pf_expMLbase_get, METH_O, NULL},
	 { "mx_pf_q_get", _wrap_mx_pf_q_get, METH_O, NULL},
	 { "mx_pf_qb_get", _wrap_mx_pf_qb_get, METH_O, NULL},
	 { "mx_pf_qm_get", _wrap_mx_pf_qm_get, METH_O, NULL},
	 { "mx_pf_qm1_get", _wrap_mx_pf_qm1_get, METH_O, NULL},
	 { "mx_pf_probs_get", _wrap_mx_pf_probs_get, METH_O, NULL},
	 { "mx_pf_q1k_get", _wrap_mx_pf_q1k_get, METH_O, NULL},
	 { "mx_pf_qln_get", _wrap_mx_pf_qln_get, METH_O, NULL},
	 { "mx_pf_qo_get", _wrap_mx_pf_qo_get, METH_O, NULL},
	 { "mx_pf_qm2_get", _wrap_mx_pf_qm2_get, METH_O, NULL},
	 { "mx_pf_qho_get", _wrap_mx_pf_qho_get, METH_O, NULL},
	 { "mx_pf_qio_get", _wrap_mx_pf_qio_get, METH_O, NULL},
	 { "mx_pf_qmo_get", _wrap_mx_pf_qmo_get, METH_O, NULL},
	 { "new_mx_pf", _wrap_new_mx_pf, METH_NOARGS, NULL},
	 { "delete_mx_pf", _wrap_delete_mx_pf, METH_O, NULL},
	 { "mx_pf_swigregister", mx_pf_swigregister, METH_O, NULL},
	 { "mx_pf_swiginit", mx_pf_swiginit, METH_VARARGS, NULL},
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_doubleArrayTo_p_double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double *)  ((doubleArray *) x));
}
static void *_p_intArrayTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((intArray *) x));
}
static void *_p_a_MAXLOOP_1__doubleArrayTo_p_a_MAXLOOP_1__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[MAXLOOP+1])  ((doubleArray (*)[MAXLOOP+1]) x));
}
static void *_p_a_5__a_5__intArrayTo_p_a_5__a_5__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[5][5])  ((intArray (*)[5][5]) x));
}
static void *_p_a_7_1__a_5__a_5__a_5__a_5__intArrayTo_p_a_7_1__a_5__a_5__a_5__a_5__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[7+1][5][5][5][5])  ((intArray (*)[7+1][5][5][5][5]) x));
}
static void *_p_a_7_1__a_5__a_5__a_5__intArrayTo_p_a_7_1__a_5__a_5__a_5__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[7+1][5][5][5])  ((intArray (*)[7+1][5][5][5]) x));
}
static void *_p_a_7_1__a_5__a_5__intArrayTo_p_a_7_1__a_5__a_5__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[7+1][5][5])  ((intArray (*)[7+1][5][5]) x));
}
static void *_p_a_5__a_5__doubleArrayTo_p_a_5__a_5__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[5][5])  ((doubleArray (*)[5][5]) x));
}
static void *_p_a_5__doubleArrayTo_p_a_5__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[5])  ((doubleArray (*)[5]) x));
}
static void *_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[NBPAIRS+1][5][5][5][5])  ((doubleArray (*)[NBPAIRS+1][5][5][5][5]) x));
}
static void *_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[NBPAIRS+1][5][5][5][5])  ((intArray (*)[NBPAIRS+1][5][5][5][5]) x));
}
static void *_p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[NBPAIRS+1][5][5][5])  ((doubleArray (*)[NBPAIRS+1][5][5][5]) x));
}
static void *_p_a_NBPAIRS_1__a_5__a_5__a_5__intArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[NBPAIRS+1][5][5][5])  ((intArray (*)[NBPAIRS+1][5][5][5]) x));
}
static void *_p_a_NBPAIRS_1__a_5__a_5__doubleArrayTo_p_a_NBPAIRS_1__a_5__a_5__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[NBPAIRS+1][5][5])  ((doubleArray (*)[NBPAIRS+1][5][5]) x));
}
static void *_p_a_NBPAIRS_1__a_5__a_5__intArrayTo_p_a_NBPAIRS_1__a_5__a_5__int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int (*)[NBPAIRS+1][5][5])  ((intArray (*)[NBPAIRS+1][5][5]) x));
}
static void *_p_a_NBPAIRS_1__doubleArrayTo_p_a_NBPAIRS_1__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[NBPAIRS+1])  ((doubleArray (*)[NBPAIRS+1]) x));
}
static void *_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArrayTo_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((double (*)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1])  ((doubleArray (*)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1]) x));
}
static void *_p_floatArrayTo_p_float(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((float *)  ((floatArray *) x));
}
static void *_p_p_intArrayTo_p_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int **)  ((intArray **) x));
}
static swig_type_info _swigt__p_COORDINATE = {"_p_COORDINATE", "std::vector< COORDINATE >::value_type *|COORDINATE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SOLUTION = {"_p_SOLUTION", "std::vector< SOLUTION >::value_type *|SOLUTION *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Tree = {"_p_Tree", "Tree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p__struct_en = {"_p__struct_en", "struct_en *|_struct_en *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double = {"_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double", "double (*)[3*VRNA_GQUAD_MAX_LINKER_LENGTH+1]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray = {"_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_5__a_5__double = {"_p_a_5__a_5__double", "double (*)[5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_5__a_5__doubleArray = {"_p_a_5__a_5__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_5__a_5__int = {"_p_a_5__a_5__int", "int (*)[5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_5__a_5__intArray = {"_p_a_5__a_5__intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_5__double = {"_p_a_5__double", "double (*)[5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_5__doubleArray = {"_p_a_5__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_7_1__a_5__a_5__a_5__a_5__int = {"_p_a_7_1__a_5__a_5__a_5__a_5__int", "int (*)[7+1][5][5][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_7_1__a_5__a_5__a_5__a_5__intArray = {"_p_a_7_1__a_5__a_5__a_5__a_5__intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_7_1__a_5__a_5__a_5__int = {"_p_a_7_1__a_5__a_5__a_5__int", "int (*)[7+1][5][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_7_1__a_5__a_5__a_5__intArray = {"_p_a_7_1__a_5__a_5__a_5__intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_7_1__a_5__a_5__int = {"_p_a_7_1__a_5__a_5__int", "int (*)[7+1][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_7_1__a_5__a_5__intArray = {"_p_a_7_1__a_5__a_5__intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_MAXLOOP_1__double = {"_p_a_MAXLOOP_1__double", "double (*)[MAXLOOP+1]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_MAXLOOP_1__doubleArray = {"_p_a_MAXLOOP_1__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double", "double (*)[NBPAIRS+1][5][5][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int", "int (*)[NBPAIRS+1][5][5][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__double = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__double", "double (*)[NBPAIRS+1][5][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__int = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__int", "int (*)[NBPAIRS+1][5][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__intArray = {"_p_a_NBPAIRS_1__a_5__a_5__a_5__intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__double = {"_p_a_NBPAIRS_1__a_5__a_5__double", "double (*)[NBPAIRS+1][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__doubleArray = {"_p_a_NBPAIRS_1__a_5__a_5__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__int = {"_p_a_NBPAIRS_1__a_5__a_5__int", "int (*)[NBPAIRS+1][5][5]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__a_5__a_5__intArray = {"_p_a_NBPAIRS_1__a_5__a_5__intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__double = {"_p_a_NBPAIRS_1__double", "double (*)[NBPAIRS+1]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NBPAIRS_1__doubleArray = {"_p_a_NBPAIRS_1__doubleArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_allocator_type = {"_p_allocator_type", "allocator_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_double = {"_p_double", "FLT_OR_DBL *|double *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_doubleArray = {"_p_doubleArray", "doubleArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_duplexT = {"_p_duplexT", "duplexT *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_duplex_list_t = {"_p_duplex_list_t", "std::vector< duplex_list_t >::value_type *|duplex_list_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_first_type = {"_p_first_type", "first_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_floatArray = {"_p_floatArray", "floatArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_heat_capacity_result = {"_p_heat_capacity_result", "std::vector< heat_capacity_result >::value_type *|heat_capacity_result *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_intArray = {"_p_intArray", "intArray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_my_fc_type_e = {"_p_my_fc_type_e", "my_fc_type_e *|enum my_fc_type_e *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_PyObject = {"_p_p_PyObject", "PyObject **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_int = {"_p_p_int", "int **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_intArray = {"_p_p_intArray", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_p_char = {"_p_p_p_char", "char ***", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_short = {"_p_p_short", "short **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_unsigned_int = {"_p_p_unsigned_int", "unsigned int **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_var_arrayT_vrna_move_t_t = {"_p_p_var_arrayT_vrna_move_t_t", "var_array< vrna_move_t > **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_second_type = {"_p_second_type", "second_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_short = {"_p_short", "short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_COORDINATE_t = {"_p_std__allocatorT_COORDINATE_t", "std::vector< COORDINATE >::allocator_type *|std::allocator< COORDINATE > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_SOLUTION_t = {"_p_std__allocatorT_SOLUTION_t", "std::vector< SOLUTION >::allocator_type *|std::allocator< SOLUTION > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_char_const_p_t = {"_p_std__allocatorT_char_const_p_t", "std::vector< char const * >::allocator_type *|std::allocator< char const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_double_t = {"_p_std__allocatorT_double_t", "std::vector< double >::allocator_type *|std::allocator< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_duplex_list_t_t = {"_p_std__allocatorT_duplex_list_t_t", "std::vector< duplex_list_t >::allocator_type *|std::allocator< duplex_list_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_heat_capacity_result_t = {"_p_std__allocatorT_heat_capacity_result_t", "std::vector< heat_capacity_result >::allocator_type *|std::allocator< heat_capacity_result > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_int_t = {"_p_std__allocatorT_int_t", "std::vector< int >::allocator_type *|std::allocator< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__string_t = {"_p_std__allocatorT_std__string_t", "std::vector< std::string >::allocator_type *|std::allocator< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_double_t_t = {"_p_std__allocatorT_std__vectorT_double_t_t", "std::vector< std::vector< double > >::allocator_type *|std::allocator< std::vector< double,std::allocator< double > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_int_t_t = {"_p_std__allocatorT_std__vectorT_int_t_t", "std::vector< std::vector< int > >::allocator_type *|std::allocator< std::vector< int,std::allocator< int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_std__vectorT_unsigned_int_t_t = {"_p_std__allocatorT_std__vectorT_unsigned_int_t_t", "std::vector< std::vector< unsigned int > >::allocator_type *|std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_subopt_solution_t = {"_p_std__allocatorT_subopt_solution_t", "std::vector< subopt_solution >::allocator_type *|std::allocator< subopt_solution > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_unsigned_int_t = {"_p_std__allocatorT_unsigned_int_t", "std::vector< unsigned int >::allocator_type *|std::allocator< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_vrna_ep_t_t = {"_p_std__allocatorT_vrna_ep_t_t", "std::vector< vrna_ep_t >::allocator_type *|std::allocator< vrna_ep_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_vrna_hx_t_t = {"_p_std__allocatorT_vrna_hx_t_t", "std::vector< vrna_hx_t >::allocator_type *|std::allocator< vrna_hx_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_vrna_move_t_t = {"_p_std__allocatorT_vrna_move_t_t", "std::vector< vrna_move_t >::allocator_type *|std::allocator< vrna_move_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__allocatorT_vrna_path_t_t = {"_p_std__allocatorT_vrna_path_t_t", "std::vector< vrna_path_t >::allocator_type *|std::allocator< vrna_path_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_double_double_t = {"_p_std__pairT_double_double_t", "std::pair< double,double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_COORDINATE_t = {"_p_std__vectorT_COORDINATE_t", "std::vector< COORDINATE,std::allocator< COORDINATE > > *|std::vector< COORDINATE > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_SOLUTION_t = {"_p_std__vectorT_SOLUTION_t", "std::vector< SOLUTION,std::allocator< SOLUTION > > *|std::vector< SOLUTION > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_char_const_p_t = {"_p_std__vectorT_char_const_p_t", "std::vector< char const *,std::allocator< char const * > > *|std::vector< char const * > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_char_std__allocatorT_char_t_t = {"_p_std__vectorT_char_std__allocatorT_char_t_t", "std::vector< char,std::allocator< char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_double_t = {"_p_std__vectorT_double_t", "std::vector< double,std::allocator< double > > *|std::vector< double > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_duplex_list_t_t = {"_p_std__vectorT_duplex_list_t_t", "std::vector< duplex_list_t,std::allocator< duplex_list_t > > *|std::vector< duplex_list_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_heat_capacity_result_t = {"_p_std__vectorT_heat_capacity_result_t", "std::vector< heat_capacity_result,std::allocator< heat_capacity_result > > *|std::vector< heat_capacity_result > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int,std::allocator< int > > *|std::vector< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_short_std__allocatorT_short_t_t = {"_p_std__vectorT_short_std__allocatorT_short_t_t", "std::vector< short,std::allocator< short > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< std::string > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_double_t_t = {"_p_std__vectorT_std__vectorT_double_t_t", "std::vector< std::vector< double,std::allocator< double > > > *|std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > *|std::vector< std::vector< double > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_int_t_t = {"_p_std__vectorT_std__vectorT_int_t_t", "std::vector< std::vector< int,std::allocator< int > > > *|std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > *|std::vector< std::vector< int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__vectorT_unsigned_int_t_t = {"_p_std__vectorT_std__vectorT_unsigned_int_t_t", "std::vector< std::vector< unsigned int,std::allocator< unsigned int > > > *|std::vector< std::vector< unsigned int,std::allocator< unsigned int > >,std::allocator< std::vector< unsigned int,std::allocator< unsigned int > > > > *|std::vector< std::vector< unsigned int > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_subopt_solution_t = {"_p_std__vectorT_subopt_solution_t", "std::vector< subopt_solution,std::allocator< subopt_solution > > *|std::vector< subopt_solution > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t = {"_p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t", "std::vector< unsigned char,std::allocator< unsigned char > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_unsigned_int_t = {"_p_std__vectorT_unsigned_int_t", "std::vector< unsigned int,std::allocator< unsigned int > > *|std::vector< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_vrna_ep_t_t = {"_p_std__vectorT_vrna_ep_t_t", "std::vector< vrna_ep_t,std::allocator< vrna_ep_t > > *|std::vector< vrna_ep_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_vrna_hx_t_t = {"_p_std__vectorT_vrna_hx_t_t", "std::vector< vrna_hx_t,std::allocator< vrna_hx_t > > *|std::vector< vrna_hx_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_vrna_move_t_t = {"_p_std__vectorT_vrna_move_t_t", "std::vector< vrna_move_t,std::allocator< vrna_move_t > > *|std::vector< vrna_move_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_vrna_path_t_t = {"_p_std__vectorT_vrna_path_t_t", "std::vector< vrna_path_t,std::allocator< vrna_path_t > > *|std::vector< vrna_path_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_subopt_solution = {"_p_subopt_solution", "std::vector< subopt_solution >::value_type *|subopt_solution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swString = {"_p_swString", "swString *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__SwigPyIterator = {"_p_swig__SwigPyIterator", "swig::SwigPyIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_var_arrayT_FLT_OR_DBL_t = {"_p_var_arrayT_FLT_OR_DBL_t", "var_array< FLT_OR_DBL > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_var_arrayT_char_t = {"_p_var_arrayT_char_t", "var_array< char > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_var_arrayT_int_t = {"_p_var_arrayT_int_t", "var_array< int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_var_arrayT_short_t = {"_p_var_arrayT_short_t", "var_array< short > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_var_arrayT_unsigned_char_t = {"_p_var_arrayT_unsigned_char_t", "var_array< unsigned char > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_var_arrayT_unsigned_int_t = {"_p_var_arrayT_unsigned_int_t", "var_array< unsigned int > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_var_arrayT_vrna_move_t_t = {"_p_var_arrayT_vrna_move_t_t", "var_array< vrna_move_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_basepair_s = {"_p_vrna_basepair_s", "vrna_bp_t *|vrna_basepair_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_basepair_t = {"_p_vrna_basepair_t", "vrna_basepair_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_bp_stack_t = {"_p_vrna_bp_stack_t", "bondT *|vrna_bp_stack_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_command_s = {"_p_vrna_command_s", "vrna_command_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_cpair_s = {"_p_vrna_cpair_s", "vrna_cpair_t *|vrna_cpair_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_dimer_pf_s = {"_p_vrna_dimer_pf_s", "cofoldF *|vrna_dimer_pf_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_dotplot_auxdata_t = {"_p_vrna_dotplot_auxdata_t", "vrna_dotplot_auxdata_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_elem_prob_s = {"_p_vrna_elem_prob_s", "plist *|vrna_elem_prob_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_ep_t = {"_p_vrna_ep_t", "std::vector< vrna_ep_t >::value_type *|vrna_ep_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_exp_param_t = {"_p_vrna_exp_param_t", "vrna_exp_param_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_fold_compound_t = {"_p_vrna_fold_compound_t", "vrna_fold_compound_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_hc_t = {"_p_vrna_hc_t", "vrna_hc_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_hx_t = {"_p_vrna_hx_t", "std::vector< vrna_hx_t >::value_type *|vrna_hx_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_md_t = {"_p_vrna_md_t", "vrna_md_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_move_t = {"_p_vrna_move_t", "std::vector< vrna_move_t >::value_type *|vrna_move_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_mx_mfe_t = {"_p_vrna_mx_mfe_t", "vrna_mx_mfe_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_mx_pf_t = {"_p_vrna_mx_pf_t", "vrna_mx_pf_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_param_t = {"_p_vrna_param_t", "vrna_param_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_path_options_s = {"_p_vrna_path_options_s", "vrna_path_options_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_path_s = {"_p_vrna_path_s", "path_t *|vrna_path_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_path_t = {"_p_vrna_path_t", "std::vector< vrna_path_t >::value_type *|vrna_path_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_pbacktrack_mem_t = {"_p_vrna_pbacktrack_mem_t", "vrna_pbacktrack_mem_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_pinfo_s = {"_p_vrna_pinfo_s", "pair_info *|vrna_pinfo_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_plot_data_t = {"_p_vrna_plot_data_t", "vrna_plot_data_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_plot_layout_t = {"_p_vrna_plot_layout_t", "vrna_plot_layout_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_plot_options_puzzler_t = {"_p_vrna_plot_options_puzzler_t", "vrna_plot_options_puzzler_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_probing_data_s = {"_p_vrna_probing_data_s", "vrna_probing_data_t|vrna_probing_data_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_sc_mod_param_s = {"_p_vrna_sc_mod_param_s", "vrna_sc_mod_param_t|vrna_sc_mod_param_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_sc_s = {"_p_vrna_sc_s", "vrna_sc_t *|vrna_sc_s *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_score_t = {"_p_vrna_score_t", "vrna_score_t *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_vrna_smx_csr_FLT_OR_DBL_s = {"_p_vrna_smx_csr_FLT_OR_DBL_s", "vrna_smx_csr_FLT_OR_DBL_t *|vrna_smx_csr_FLT_OR_DBL_s *", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_COORDINATE,
  &_swigt__p_FILE,
  &_swigt__p_SOLUTION,
  &_swigt__p_Tree,
  &_swigt__p__struct_en,
  &_swigt__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double,
  &_swigt__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray,
  &_swigt__p_a_5__a_5__double,
  &_swigt__p_a_5__a_5__doubleArray,
  &_swigt__p_a_5__a_5__int,
  &_swigt__p_a_5__a_5__intArray,
  &_swigt__p_a_5__double,
  &_swigt__p_a_5__doubleArray,
  &_swigt__p_a_7_1__a_5__a_5__a_5__a_5__int,
  &_swigt__p_a_7_1__a_5__a_5__a_5__a_5__intArray,
  &_swigt__p_a_7_1__a_5__a_5__a_5__int,
  &_swigt__p_a_7_1__a_5__a_5__a_5__intArray,
  &_swigt__p_a_7_1__a_5__a_5__int,
  &_swigt__p_a_7_1__a_5__a_5__intArray,
  &_swigt__p_a_MAXLOOP_1__double,
  &_swigt__p_a_MAXLOOP_1__doubleArray,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__double,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__int,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__intArray,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__double,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__doubleArray,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__int,
  &_swigt__p_a_NBPAIRS_1__a_5__a_5__intArray,
  &_swigt__p_a_NBPAIRS_1__double,
  &_swigt__p_a_NBPAIRS_1__doubleArray,
  &_swigt__p_allocator_type,
  &_swigt__p_char,
  &_swigt__p_difference_type,
  &_swigt__p_double,
  &_swigt__p_doubleArray,
  &_swigt__p_duplexT,
  &_swigt__p_duplex_list_t,
  &_swigt__p_first_type,
  &_swigt__p_float,
  &_swigt__p_floatArray,
  &_swigt__p_heat_capacity_result,
  &_swigt__p_int,
  &_swigt__p_intArray,
  &_swigt__p_my_fc_type_e,
  &_swigt__p_p_PyObject,
  &_swigt__p_p_char,
  &_swigt__p_p_int,
  &_swigt__p_p_intArray,
  &_swigt__p_p_p_char,
  &_swigt__p_p_short,
  &_swigt__p_p_unsigned_int,
  &_swigt__p_p_var_arrayT_vrna_move_t_t,
  &_swigt__p_p_void,
  &_swigt__p_second_type,
  &_swigt__p_short,
  &_swigt__p_size_type,
  &_swigt__p_std__allocatorT_COORDINATE_t,
  &_swigt__p_std__allocatorT_SOLUTION_t,
  &_swigt__p_std__allocatorT_char_const_p_t,
  &_swigt__p_std__allocatorT_double_t,
  &_swigt__p_std__allocatorT_duplex_list_t_t,
  &_swigt__p_std__allocatorT_heat_capacity_result_t,
  &_swigt__p_std__allocatorT_int_t,
  &_swigt__p_std__allocatorT_std__string_t,
  &_swigt__p_std__allocatorT_std__vectorT_double_t_t,
  &_swigt__p_std__allocatorT_std__vectorT_int_t_t,
  &_swigt__p_std__allocatorT_std__vectorT_unsigned_int_t_t,
  &_swigt__p_std__allocatorT_subopt_solution_t,
  &_swigt__p_std__allocatorT_unsigned_int_t,
  &_swigt__p_std__allocatorT_vrna_ep_t_t,
  &_swigt__p_std__allocatorT_vrna_hx_t_t,
  &_swigt__p_std__allocatorT_vrna_move_t_t,
  &_swigt__p_std__allocatorT_vrna_path_t_t,
  &_swigt__p_std__pairT_double_double_t,
  &_swigt__p_std__string,
  &_swigt__p_std__vectorT_COORDINATE_t,
  &_swigt__p_std__vectorT_SOLUTION_t,
  &_swigt__p_std__vectorT_char_const_p_t,
  &_swigt__p_std__vectorT_char_std__allocatorT_char_t_t,
  &_swigt__p_std__vectorT_double_t,
  &_swigt__p_std__vectorT_duplex_list_t_t,
  &_swigt__p_std__vectorT_heat_capacity_result_t,
  &_swigt__p_std__vectorT_int_t,
  &_swigt__p_std__vectorT_short_std__allocatorT_short_t_t,
  &_swigt__p_std__vectorT_std__string_t,
  &_swigt__p_std__vectorT_std__vectorT_double_t_t,
  &_swigt__p_std__vectorT_std__vectorT_int_t_t,
  &_swigt__p_std__vectorT_std__vectorT_unsigned_int_t_t,
  &_swigt__p_std__vectorT_subopt_solution_t,
  &_swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t,
  &_swigt__p_std__vectorT_unsigned_int_t,
  &_swigt__p_std__vectorT_vrna_ep_t_t,
  &_swigt__p_std__vectorT_vrna_hx_t_t,
  &_swigt__p_std__vectorT_vrna_move_t_t,
  &_swigt__p_std__vectorT_vrna_path_t_t,
  &_swigt__p_subopt_solution,
  &_swigt__p_swString,
  &_swigt__p_swig__SwigPyIterator,
  &_swigt__p_unsigned_int,
  &_swigt__p_unsigned_short,
  &_swigt__p_value_type,
  &_swigt__p_var_arrayT_FLT_OR_DBL_t,
  &_swigt__p_var_arrayT_char_t,
  &_swigt__p_var_arrayT_int_t,
  &_swigt__p_var_arrayT_short_t,
  &_swigt__p_var_arrayT_unsigned_char_t,
  &_swigt__p_var_arrayT_unsigned_int_t,
  &_swigt__p_var_arrayT_vrna_move_t_t,
  &_swigt__p_void,
  &_swigt__p_vrna_basepair_s,
  &_swigt__p_vrna_basepair_t,
  &_swigt__p_vrna_bp_stack_t,
  &_swigt__p_vrna_command_s,
  &_swigt__p_vrna_cpair_s,
  &_swigt__p_vrna_dimer_pf_s,
  &_swigt__p_vrna_dotplot_auxdata_t,
  &_swigt__p_vrna_elem_prob_s,
  &_swigt__p_vrna_ep_t,
  &_swigt__p_vrna_exp_param_t,
  &_swigt__p_vrna_fold_compound_t,
  &_swigt__p_vrna_hc_t,
  &_swigt__p_vrna_hx_t,
  &_swigt__p_vrna_md_t,
  &_swigt__p_vrna_move_t,
  &_swigt__p_vrna_mx_mfe_t,
  &_swigt__p_vrna_mx_pf_t,
  &_swigt__p_vrna_param_t,
  &_swigt__p_vrna_path_options_s,
  &_swigt__p_vrna_path_s,
  &_swigt__p_vrna_path_t,
  &_swigt__p_vrna_pbacktrack_mem_t,
  &_swigt__p_vrna_pinfo_s,
  &_swigt__p_vrna_plot_data_t,
  &_swigt__p_vrna_plot_layout_t,
  &_swigt__p_vrna_plot_options_puzzler_t,
  &_swigt__p_vrna_probing_data_s,
  &_swigt__p_vrna_sc_mod_param_s,
  &_swigt__p_vrna_sc_s,
  &_swigt__p_vrna_score_t,
  &_swigt__p_vrna_smx_csr_FLT_OR_DBL_s,
};

static swig_cast_info _swigc__p_COORDINATE[] = {  {&_swigt__p_COORDINATE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_FILE[] = {  {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SOLUTION[] = {  {&_swigt__p_SOLUTION, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Tree[] = {  {&_swigt__p_Tree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p__struct_en[] = {  {&_swigt__p__struct_en, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray[] = {{&_swigt__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double[] = {  {&_swigt__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double, 0, 0, 0},  {&_swigt__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray, _p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArrayTo_p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__a_5__doubleArray[] = {{&_swigt__p_a_5__a_5__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__a_5__double[] = {  {&_swigt__p_a_5__a_5__double, 0, 0, 0},  {&_swigt__p_a_5__a_5__doubleArray, _p_a_5__a_5__doubleArrayTo_p_a_5__a_5__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__a_5__intArray[] = {{&_swigt__p_a_5__a_5__intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__a_5__int[] = {  {&_swigt__p_a_5__a_5__int, 0, 0, 0},  {&_swigt__p_a_5__a_5__intArray, _p_a_5__a_5__intArrayTo_p_a_5__a_5__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__doubleArray[] = {{&_swigt__p_a_5__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_5__double[] = {  {&_swigt__p_a_5__double, 0, 0, 0},  {&_swigt__p_a_5__doubleArray, _p_a_5__doubleArrayTo_p_a_5__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_7_1__a_5__a_5__a_5__a_5__intArray[] = {{&_swigt__p_a_7_1__a_5__a_5__a_5__a_5__intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_7_1__a_5__a_5__a_5__a_5__int[] = {  {&_swigt__p_a_7_1__a_5__a_5__a_5__a_5__int, 0, 0, 0},  {&_swigt__p_a_7_1__a_5__a_5__a_5__a_5__intArray, _p_a_7_1__a_5__a_5__a_5__a_5__intArrayTo_p_a_7_1__a_5__a_5__a_5__a_5__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_7_1__a_5__a_5__a_5__intArray[] = {{&_swigt__p_a_7_1__a_5__a_5__a_5__intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_7_1__a_5__a_5__a_5__int[] = {  {&_swigt__p_a_7_1__a_5__a_5__a_5__int, 0, 0, 0},  {&_swigt__p_a_7_1__a_5__a_5__a_5__intArray, _p_a_7_1__a_5__a_5__a_5__intArrayTo_p_a_7_1__a_5__a_5__a_5__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_7_1__a_5__a_5__intArray[] = {{&_swigt__p_a_7_1__a_5__a_5__intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_7_1__a_5__a_5__int[] = {  {&_swigt__p_a_7_1__a_5__a_5__int, 0, 0, 0},  {&_swigt__p_a_7_1__a_5__a_5__intArray, _p_a_7_1__a_5__a_5__intArrayTo_p_a_7_1__a_5__a_5__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_MAXLOOP_1__doubleArray[] = {{&_swigt__p_a_MAXLOOP_1__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_MAXLOOP_1__double[] = {  {&_swigt__p_a_MAXLOOP_1__double, 0, 0, 0},  {&_swigt__p_a_MAXLOOP_1__doubleArray, _p_a_MAXLOOP_1__doubleArrayTo_p_a_MAXLOOP_1__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray[] = {{&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double[] = {  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double, 0, 0, 0},  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray, _p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray[] = {{&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int[] = {  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int, 0, 0, 0},  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray, _p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray[] = {{&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__double[] = {  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__double, 0, 0, 0},  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray, _p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__intArray[] = {{&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__int[] = {  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__int, 0, 0, 0},  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__a_5__intArray, _p_a_NBPAIRS_1__a_5__a_5__a_5__intArrayTo_p_a_NBPAIRS_1__a_5__a_5__a_5__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__doubleArray[] = {{&_swigt__p_a_NBPAIRS_1__a_5__a_5__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__double[] = {  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__double, 0, 0, 0},  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__doubleArray, _p_a_NBPAIRS_1__a_5__a_5__doubleArrayTo_p_a_NBPAIRS_1__a_5__a_5__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__intArray[] = {{&_swigt__p_a_NBPAIRS_1__a_5__a_5__intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__a_5__a_5__int[] = {  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__int, 0, 0, 0},  {&_swigt__p_a_NBPAIRS_1__a_5__a_5__intArray, _p_a_NBPAIRS_1__a_5__a_5__intArrayTo_p_a_NBPAIRS_1__a_5__a_5__int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__doubleArray[] = {{&_swigt__p_a_NBPAIRS_1__doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NBPAIRS_1__double[] = {  {&_swigt__p_a_NBPAIRS_1__double, 0, 0, 0},  {&_swigt__p_a_NBPAIRS_1__doubleArray, _p_a_NBPAIRS_1__doubleArrayTo_p_a_NBPAIRS_1__double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_allocator_type[] = {  {&_swigt__p_allocator_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_difference_type[] = {  {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},  {&_swigt__p_doubleArray, _p_doubleArrayTo_p_double, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_doubleArray[] = {  {&_swigt__p_doubleArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_duplexT[] = {  {&_swigt__p_duplexT, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_duplex_list_t[] = {  {&_swigt__p_duplex_list_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_first_type[] = {  {&_swigt__p_first_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},  {&_swigt__p_floatArray, _p_floatArrayTo_p_float, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_floatArray[] = {  {&_swigt__p_floatArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_heat_capacity_result[] = {  {&_swigt__p_heat_capacity_result, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},  {&_swigt__p_intArray, _p_intArrayTo_p_int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_intArray[] = {  {&_swigt__p_intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_my_fc_type_e[] = {  {&_swigt__p_my_fc_type_e, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_PyObject[] = {  {&_swigt__p_p_PyObject, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_intArray[] = {{&_swigt__p_p_intArray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_int[] = {  {&_swigt__p_p_int, 0, 0, 0},  {&_swigt__p_p_intArray, _p_p_intArrayTo_p_p_int, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_p_char[] = {  {&_swigt__p_p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_short[] = {  {&_swigt__p_p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_unsigned_int[] = {  {&_swigt__p_p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_var_arrayT_vrna_move_t_t[] = {  {&_swigt__p_p_var_arrayT_vrna_move_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_second_type[] = {  {&_swigt__p_second_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_size_type[] = {  {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_COORDINATE_t[] = {  {&_swigt__p_std__allocatorT_COORDINATE_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_SOLUTION_t[] = {  {&_swigt__p_std__allocatorT_SOLUTION_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_char_const_p_t[] = {  {&_swigt__p_std__allocatorT_char_const_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_double_t[] = {  {&_swigt__p_std__allocatorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_duplex_list_t_t[] = {  {&_swigt__p_std__allocatorT_duplex_list_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_heat_capacity_result_t[] = {  {&_swigt__p_std__allocatorT_heat_capacity_result_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_int_t[] = {  {&_swigt__p_std__allocatorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__string_t[] = {  {&_swigt__p_std__allocatorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_double_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_int_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_std__vectorT_unsigned_int_t_t[] = {  {&_swigt__p_std__allocatorT_std__vectorT_unsigned_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_subopt_solution_t[] = {  {&_swigt__p_std__allocatorT_subopt_solution_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_unsigned_int_t[] = {  {&_swigt__p_std__allocatorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_vrna_ep_t_t[] = {  {&_swigt__p_std__allocatorT_vrna_ep_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_vrna_hx_t_t[] = {  {&_swigt__p_std__allocatorT_vrna_hx_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_vrna_move_t_t[] = {  {&_swigt__p_std__allocatorT_vrna_move_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__allocatorT_vrna_path_t_t[] = {  {&_swigt__p_std__allocatorT_vrna_path_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_double_double_t[] = {  {&_swigt__p_std__pairT_double_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_COORDINATE_t[] = {  {&_swigt__p_std__vectorT_COORDINATE_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_SOLUTION_t[] = {  {&_swigt__p_std__vectorT_SOLUTION_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_char_const_p_t[] = {  {&_swigt__p_std__vectorT_char_const_p_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_char_std__allocatorT_char_t_t[] = {  {&_swigt__p_std__vectorT_char_std__allocatorT_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_double_t[] = {  {&_swigt__p_std__vectorT_double_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_duplex_list_t_t[] = {  {&_swigt__p_std__vectorT_duplex_list_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_heat_capacity_result_t[] = {  {&_swigt__p_std__vectorT_heat_capacity_result_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_int_t[] = {  {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_short_std__allocatorT_short_t_t[] = {  {&_swigt__p_std__vectorT_short_std__allocatorT_short_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = {  {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_double_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_double_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_int_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__vectorT_unsigned_int_t_t[] = {  {&_swigt__p_std__vectorT_std__vectorT_unsigned_int_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_subopt_solution_t[] = {  {&_swigt__p_std__vectorT_subopt_solution_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t[] = {  {&_swigt__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_unsigned_int_t[] = {  {&_swigt__p_std__vectorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_vrna_ep_t_t[] = {  {&_swigt__p_std__vectorT_vrna_ep_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_vrna_hx_t_t[] = {  {&_swigt__p_std__vectorT_vrna_hx_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_vrna_move_t_t[] = {  {&_swigt__p_std__vectorT_vrna_move_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_vrna_path_t_t[] = {  {&_swigt__p_std__vectorT_vrna_path_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_subopt_solution[] = {  {&_swigt__p_subopt_solution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swString[] = {  {&_swigt__p_swString, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__SwigPyIterator[] = {  {&_swigt__p_swig__SwigPyIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_value_type[] = {  {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_var_arrayT_FLT_OR_DBL_t[] = {  {&_swigt__p_var_arrayT_FLT_OR_DBL_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_var_arrayT_char_t[] = {  {&_swigt__p_var_arrayT_char_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_var_arrayT_int_t[] = {  {&_swigt__p_var_arrayT_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_var_arrayT_short_t[] = {  {&_swigt__p_var_arrayT_short_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_var_arrayT_unsigned_char_t[] = {  {&_swigt__p_var_arrayT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_var_arrayT_unsigned_int_t[] = {  {&_swigt__p_var_arrayT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_var_arrayT_vrna_move_t_t[] = {  {&_swigt__p_var_arrayT_vrna_move_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_basepair_s[] = {  {&_swigt__p_vrna_basepair_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_basepair_t[] = {  {&_swigt__p_vrna_basepair_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_bp_stack_t[] = {  {&_swigt__p_vrna_bp_stack_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_command_s[] = {  {&_swigt__p_vrna_command_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_cpair_s[] = {  {&_swigt__p_vrna_cpair_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_dimer_pf_s[] = {  {&_swigt__p_vrna_dimer_pf_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_dotplot_auxdata_t[] = {  {&_swigt__p_vrna_dotplot_auxdata_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_elem_prob_s[] = {  {&_swigt__p_vrna_elem_prob_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_ep_t[] = {  {&_swigt__p_vrna_ep_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_exp_param_t[] = {  {&_swigt__p_vrna_exp_param_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_fold_compound_t[] = {  {&_swigt__p_vrna_fold_compound_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_hc_t[] = {  {&_swigt__p_vrna_hc_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_hx_t[] = {  {&_swigt__p_vrna_hx_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_md_t[] = {  {&_swigt__p_vrna_md_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_move_t[] = {  {&_swigt__p_vrna_move_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_mx_mfe_t[] = {  {&_swigt__p_vrna_mx_mfe_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_mx_pf_t[] = {  {&_swigt__p_vrna_mx_pf_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_param_t[] = {  {&_swigt__p_vrna_param_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_path_options_s[] = {  {&_swigt__p_vrna_path_options_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_path_s[] = {  {&_swigt__p_vrna_path_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_path_t[] = {  {&_swigt__p_vrna_path_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_pbacktrack_mem_t[] = {  {&_swigt__p_vrna_pbacktrack_mem_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_pinfo_s[] = {  {&_swigt__p_vrna_pinfo_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_plot_data_t[] = {  {&_swigt__p_vrna_plot_data_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_plot_layout_t[] = {  {&_swigt__p_vrna_plot_layout_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_plot_options_puzzler_t[] = {  {&_swigt__p_vrna_plot_options_puzzler_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_probing_data_s[] = {  {&_swigt__p_vrna_probing_data_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_sc_mod_param_s[] = {  {&_swigt__p_vrna_sc_mod_param_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_sc_s[] = {  {&_swigt__p_vrna_sc_s, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_score_t[] = {  {&_swigt__p_vrna_score_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_vrna_smx_csr_FLT_OR_DBL_s[] = {  {&_swigt__p_vrna_smx_csr_FLT_OR_DBL_s, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_COORDINATE,
  _swigc__p_FILE,
  _swigc__p_SOLUTION,
  _swigc__p_Tree,
  _swigc__p__struct_en,
  _swigc__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__double,
  _swigc__p_a_3_VRNA_GQUAD_MAX_LINKER_LENGTH_1__doubleArray,
  _swigc__p_a_5__a_5__double,
  _swigc__p_a_5__a_5__doubleArray,
  _swigc__p_a_5__a_5__int,
  _swigc__p_a_5__a_5__intArray,
  _swigc__p_a_5__double,
  _swigc__p_a_5__doubleArray,
  _swigc__p_a_7_1__a_5__a_5__a_5__a_5__int,
  _swigc__p_a_7_1__a_5__a_5__a_5__a_5__intArray,
  _swigc__p_a_7_1__a_5__a_5__a_5__int,
  _swigc__p_a_7_1__a_5__a_5__a_5__intArray,
  _swigc__p_a_7_1__a_5__a_5__int,
  _swigc__p_a_7_1__a_5__a_5__intArray,
  _swigc__p_a_MAXLOOP_1__double,
  _swigc__p_a_MAXLOOP_1__doubleArray,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__double,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__doubleArray,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__int,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__a_5__intArray,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__double,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__doubleArray,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__int,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__a_5__intArray,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__double,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__doubleArray,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__int,
  _swigc__p_a_NBPAIRS_1__a_5__a_5__intArray,
  _swigc__p_a_NBPAIRS_1__double,
  _swigc__p_a_NBPAIRS_1__doubleArray,
  _swigc__p_allocator_type,
  _swigc__p_char,
  _swigc__p_difference_type,
  _swigc__p_double,
  _swigc__p_doubleArray,
  _swigc__p_duplexT,
  _swigc__p_duplex_list_t,
  _swigc__p_first_type,
  _swigc__p_float,
  _swigc__p_floatArray,
  _swigc__p_heat_capacity_result,
  _swigc__p_int,
  _swigc__p_intArray,
  _swigc__p_my_fc_type_e,
  _swigc__p_p_PyObject,
  _swigc__p_p_char,
  _swigc__p_p_int,
  _swigc__p_p_intArray,
  _swigc__p_p_p_char,
  _swigc__p_p_short,
  _swigc__p_p_unsigned_int,
  _swigc__p_p_var_arrayT_vrna_move_t_t,
  _swigc__p_p_void,
  _swigc__p_second_type,
  _swigc__p_short,
  _swigc__p_size_type,
  _swigc__p_std__allocatorT_COORDINATE_t,
  _swigc__p_std__allocatorT_SOLUTION_t,
  _swigc__p_std__allocatorT_char_const_p_t,
  _swigc__p_std__allocatorT_double_t,
  _swigc__p_std__allocatorT_duplex_list_t_t,
  _swigc__p_std__allocatorT_heat_capacity_result_t,
  _swigc__p_std__allocatorT_int_t,
  _swigc__p_std__allocatorT_std__string_t,
  _swigc__p_std__allocatorT_std__vectorT_double_t_t,
  _swigc__p_std__allocatorT_std__vectorT_int_t_t,
  _swigc__p_std__allocatorT_std__vectorT_unsigned_int_t_t,
  _swigc__p_std__allocatorT_subopt_solution_t,
  _swigc__p_std__allocatorT_unsigned_int_t,
  _swigc__p_std__allocatorT_vrna_ep_t_t,
  _swigc__p_std__allocatorT_vrna_hx_t_t,
  _swigc__p_std__allocatorT_vrna_move_t_t,
  _swigc__p_std__allocatorT_vrna_path_t_t,
  _swigc__p_std__pairT_double_double_t,
  _swigc__p_std__string,
  _swigc__p_std__vectorT_COORDINATE_t,
  _swigc__p_std__vectorT_SOLUTION_t,
  _swigc__p_std__vectorT_char_const_p_t,
  _swigc__p_std__vectorT_char_std__allocatorT_char_t_t,
  _swigc__p_std__vectorT_double_t,
  _swigc__p_std__vectorT_duplex_list_t_t,
  _swigc__p_std__vectorT_heat_capacity_result_t,
  _swigc__p_std__vectorT_int_t,
  _swigc__p_std__vectorT_short_std__allocatorT_short_t_t,
  _swigc__p_std__vectorT_std__string_t,
  _swigc__p_std__vectorT_std__vectorT_double_t_t,
  _swigc__p_std__vectorT_std__vectorT_int_t_t,
  _swigc__p_std__vectorT_std__vectorT_unsigned_int_t_t,
  _swigc__p_std__vectorT_subopt_solution_t,
  _swigc__p_std__vectorT_unsigned_char_std__allocatorT_unsigned_char_t_t,
  _swigc__p_std__vectorT_unsigned_int_t,
  _swigc__p_std__vectorT_vrna_ep_t_t,
  _swigc__p_std__vectorT_vrna_hx_t_t,
  _swigc__p_std__vectorT_vrna_move_t_t,
  _swigc__p_std__vectorT_vrna_path_t_t,
  _swigc__p_subopt_solution,
  _swigc__p_swString,
  _swigc__p_swig__SwigPyIterator,
  _swigc__p_unsigned_int,
  _swigc__p_unsigned_short,
  _swigc__p_value_type,
  _swigc__p_var_arrayT_FLT_OR_DBL_t,
  _swigc__p_var_arrayT_char_t,
  _swigc__p_var_arrayT_int_t,
  _swigc__p_var_arrayT_short_t,
  _swigc__p_var_arrayT_unsigned_char_t,
  _swigc__p_var_arrayT_unsigned_int_t,
  _swigc__p_var_arrayT_vrna_move_t_t,
  _swigc__p_void,
  _swigc__p_vrna_basepair_s,
  _swigc__p_vrna_basepair_t,
  _swigc__p_vrna_bp_stack_t,
  _swigc__p_vrna_command_s,
  _swigc__p_vrna_cpair_s,
  _swigc__p_vrna_dimer_pf_s,
  _swigc__p_vrna_dotplot_auxdata_t,
  _swigc__p_vrna_elem_prob_s,
  _swigc__p_vrna_ep_t,
  _swigc__p_vrna_exp_param_t,
  _swigc__p_vrna_fold_compound_t,
  _swigc__p_vrna_hc_t,
  _swigc__p_vrna_hx_t,
  _swigc__p_vrna_md_t,
  _swigc__p_vrna_move_t,
  _swigc__p_vrna_mx_mfe_t,
  _swigc__p_vrna_mx_pf_t,
  _swigc__p_vrna_param_t,
  _swigc__p_vrna_path_options_s,
  _swigc__p_vrna_path_s,
  _swigc__p_vrna_path_t,
  _swigc__p_vrna_pbacktrack_mem_t,
  _swigc__p_vrna_pinfo_s,
  _swigc__p_vrna_plot_data_t,
  _swigc__p_vrna_plot_layout_t,
  _swigc__p_vrna_plot_options_puzzler_t,
  _swigc__p_vrna_probing_data_s,
  _swigc__p_vrna_sc_mod_param_s,
  _swigc__p_vrna_sc_s,
  _swigc__p_vrna_score_t,
  _swigc__p_vrna_smx_csr_FLT_OR_DBL_s,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is made tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast dependencies. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns.
 *
 * We loop through the cast[] array associated with the type and mark casts
 * which have not been defined in previously loaded modules by assigning
 * cast pointer value to cast->next. We also hash cast->type->name string
 * and store the value in the cast->value field. If we encounter swig_cast_info
 * structure that represents a cast to self we move it to the beginning
 * of the cast array. One trick we need to do is making sure the type pointer
 * in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the list (because the cast->type) pointer will
 *     be correct.
 *
 * Once the cast array has been set up AND it does have new casts that need
 * to be added we sort non-self cast entries to move filtered out entries
 * to the end of the array and to arrange the rest in the increasing order
 * of their type pointer values. We store the index of the last added entry
 * in the cast->value field of the entry[0] (overwriting the name hash). Then
 * we sort <next|value> fields of the remaining entries to arrange hash values
 * in the increasing order. This way cast->next->type->name field matches
 * the cast->value hash.
 *
 * Example:
 * Array of casts for type stored at 0x5000, cast to type stored at 0x3000
 * has already been loaded
 *
 *      After sweep-and-hash:   After sort-by-type:    After sort-by-hash:
 *        ________________       ________________       ________________
 *       |                |     |                |     |                |
 * Entry |  type = 0x5000 |     |  type = 0x5000 |     |  type = 0x5000 |
 *   0   |                |     |                |     |                |
 *       |  next = Entry0 |     |  next = Entry0 |     |  next = Entry0 |
 *       | value = 1212   |     | value = 3      |     | value = 3      |
 *       |                |     |                |     |                |
 *       |================|     |================|     |================|
 *       |                |     |                |     |                |
 * Entry |  type = 0x2000 |     |  type = 0x1000 |     |  type = 0x1000 |
 *   1   |                |     |                |     |                |
 *       |  next = Entry1 |     |  next = Entry1 |     |  next = Entry3 |
 *       | value = 3434   |     | value = 4545   |     | value = 2323   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x3000 |     |  type = 0x2000 |     |  type = 0x2000 |
 *   2   |                |     |                |     |                |
 *       |  next = 0      |     |  next = Entry2 |     |  next = Entry2 |
 *       | value = 0      |     | value = 3434   |     | value = 3434   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x1000 |     |  type = 0x4000 |     |  type = 0x4000 |
 *   3   |                |     |                |     |                |
 *       |  next = Entry3 |     |  next = Entry3 |     |  next = Entry1 |
 *       | value = 4545   |     | value = 2323   |     | value = 4545   |
 *       |________________|     |________________|     |________________|
 *       |                |     |                |     |                |
 * Entry |  type = 0x4000 |     |  type = 0x3000 |     |  type = 0x3000 |
 *   4   |                |     |                |     |                |
 *       |  next = Entry4 |     |  next = 0      |     |  next = 0      |
 *       | value = 2323   |     | value = 0      |     | value = 0      |
 *       |________________|     |________________|     |________________|
 *
 * Once the cast array has been initialized, we use cast[0]->next field to link
 * it into the list of cast arrays for the type.
 *              ____    ____    ____
 * type->cast->|next|->|next|->|next|->0
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *             |----|  |----|  |----|
 *
 * Subsequent cast resolution works as follows:
 *
 * 1. Check whether the type matches the first entry in the current cast array.
 * 2. If not, then do a binary search over the (0:cast->value] interval using
 *    either type address or the hash value of the type name.
 * 3. If not found, then move over to the next cast array (cast[0]->next).
 *
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif

#ifndef SWIG_INIT_CLIENT_DATA_TYPE
#define SWIG_INIT_CLIENT_DATA_TYPE void *
#endif

/*
 * Sort function that puts cast entries with nonzero 'next' at the front
 * of the array while ordering them by addresses of their 'type' structs.
 */
SWIGINTERN int SWIG_CastCmpStruct(const void *pa, const void *pb) {
  swig_cast_info *pca = (swig_cast_info *)pa;
  swig_cast_info *pcb = (swig_cast_info *)pb;
  if (pca->type < pcb->type)
  return (pca->next || pcb->next == 0) ? -1 : 1;
  if (pca->type > pcb->type)
  return (pcb->next || pca->next == 0) ? 1 : -1;
  return 0;
}

/*
 * Shell-sort 'next' and 'value' field pairs to order them by 'value'.
 */
SWIGINTERN void SWIG_CastHashSort(swig_cast_info *cast, int size) {
  const int hmax = size/9;
  int h, i;
  for(h = 1; h <= hmax; h = 3*h+1);
  for(; h > 0; h /= 3)
  {
    for(i = h; i < size; ++i)
    {
      swig_cast_info *p = cast[i].next;
      unsigned int hash = cast[i].value;
      int j = i;
      while(j >= h && hash < cast[j-h].value)
      {
        cast[j].next = cast[j-h].next;
        cast[j].value = cast[j-h].value;
        j -= h;
      }
      cast[j].next = p;
      cast[j].value = hash;
    }
  }
}

SWIGRUNTIME void
SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *target_type;
    swig_cast_info *cast, *first;
    int num_mapped = 0;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = first = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      target_type = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        target_type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
        if (target_type) {
          /* Target type already defined in another module */
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: found cast %s\n", target_type->name);
#endif
          if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
            printf("SWIG_InitializeModule: skip old type %s\n", target_type->name);
#endif
            cast->type = target_type;
            target_type = 0;
          } else {
            /* Check if this cast is already in the list */
            swig_cast_info *ocast = SWIG_TypeCheck(target_type->name, type);
#ifdef SWIGRUNTIME_DEBUG
            if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", target_type->name);
#endif
            if (!ocast) target_type = 0;
          }
        }
      }
      
      if (!target_type) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        /* Set inclusion mark for sorting */
        cast->next = cast;
        num_mapped++;
        
        if (type == cast->type) {
#ifdef SWIGRUNTIME_DEBUG
          printf("%s : self cast at pos [%li]\n", type->name, cast - first);
#endif
          if (cast - first) {
            /* Move cast to itself to the first entry in the array */
            
            swig_cast_info tmp = *cast;
            *cast = *first;
            *first = tmp;
          }
          first++;
          
        } else {
          cast->value = SWIG_Hash(cast->type->name, (unsigned int)strlen(cast->type->name));
        }
      }
      cast++;
    }
    
    if (num_mapped) {
      if (cast - first) {
        swig_cast_info *tmp;
        
        /* Sort casts by type address for binary search in SWIG_TypeCheckStruct */
        qsort(first, cast - first, sizeof(swig_cast_info), SWIG_CastCmpStruct);
        
        /* Remap back links for added entries */
        cast = swig_module.cast_initial[i] + num_mapped;
        for (tmp = first; tmp < cast; tmp++) {
          tmp->next = tmp;
        }
      }
      
      /* Set the value field of the first entry to the index of the last added entry */
      cast = swig_module.cast_initial[i];
      cast->value = num_mapped - 1;
      
      num_mapped -= (int)(first - cast);
      if (num_mapped > 1) {
        /* Sort <'next','value'> pairs by 'value' for binary search in SWIG_TypeCheck */
        
        SWIG_CastHashSort(first, num_mapped);
      }
      
      first = type->cast;
      if (first) {
        /* Link the current set into the list of cast arrays */
        cast->next = first->next;
        first->next = cast;
      } else {
        cast->next = 0;
        type->cast = cast;
      }
    }
    
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      swig_cast_info *head, *cast;
      head = swig_module.types[i]->cast;
      while (head) {
        for (cast = head; (cast - head) <= head->value; cast++) {
          if (!cast->converter) {
            if (cast->type && !cast->type->clientdata)
            SWIG_TypeClientData(cast->type, swig_module.types[i]->clientdata);
          }
        }
        head = head->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        SWIG_Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------
   * Patch %callback methods' docstrings to hold the callback ptrs
   * -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods, const swig_const_info *const_table, swig_type_info **types, swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        const swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
#ifdef __cplusplus
}
#endif




/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

SWIGINTERN int SWIG_mod_exec(PyObject *module);

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
#if PY_VERSION_HEX >= 0x03000000
  static PyModuleDef_Slot SwigSlots[] = {
    {
      Py_mod_exec, (void *)SWIG_mod_exec 
    },
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
    {
      Py_mod_gil, Py_MOD_GIL_NOT_USED 
    },
#endif
#endif
    {
      0, NULL 
    }
  };
  
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    0,
    SwigMethods,
    SwigSlots,
    NULL,
    NULL,
    NULL
  };
  
  return PyModuleDef_Init(&SWIG_module);
#else
  PyObject *m = Py_InitModule(SWIG_name, SwigMethods);
  if (m && SWIG_mod_exec(m) != 0) {
    Py_DECREF(m);
  }
#endif
}

SWIGINTERN int SWIG_mod_exec(PyObject *m) {
  PyObject *d, *md, *globals;
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType_Type();
  assert(metatype);
  
  SwigPyStaticVar_Type();
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_runtime_data_module();
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_Type();
  SwigVarLink_Type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_Type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#ifdef SWIGPYTHON_NOGIL
#ifdef Py_GIL_DISABLED
  PyUnstable_Module_SetGIL(m, Py_MOD_GIL_NOT_USED);
#endif
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
    return -1;
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_Type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  SWIG_Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  
  // thread safe initialization
  swig::container_owner_attribute();
  
  
  /* always initialize the random number generator when loading the module */
  vrna_init_rand();
  
  SWIG_Python_SetConstant(d, "VAR_ARRAY_LINEAR",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VAR_ARRAY_LINEAR)));
  SWIG_Python_SetConstant(d, "VAR_ARRAY_TRI",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VAR_ARRAY_TRI)));
  SWIG_Python_SetConstant(d, "VAR_ARRAY_SQR",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VAR_ARRAY_SQR)));
  SWIG_Python_SetConstant(d, "VAR_ARRAY_ONE_BASED",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VAR_ARRAY_ONE_BASED)));
  SWIG_Python_SetConstant(d, "VAR_ARRAY_OWNED",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VAR_ARRAY_OWNED)));
  SWIG_Python_SetConstant(d, "PARAMETER_FORMAT_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PARAMETER_FORMAT_DEFAULT)));
  SWIG_Python_SetConstant(d, "UNKNOWN",SWIG_From_int(static_cast< int >(UNKNOWN)));
  SWIG_Python_SetConstant(d, "QUIT",SWIG_From_int(static_cast< int >(QUIT)));
  SWIG_Python_SetConstant(d, "S",SWIG_From_int(static_cast< int >(S)));
  SWIG_Python_SetConstant(d, "S_H",SWIG_From_int(static_cast< int >(S_H)));
  SWIG_Python_SetConstant(d, "HP",SWIG_From_int(static_cast< int >(HP)));
  SWIG_Python_SetConstant(d, "HP_H",SWIG_From_int(static_cast< int >(HP_H)));
  SWIG_Python_SetConstant(d, "B",SWIG_From_int(static_cast< int >(B)));
  SWIG_Python_SetConstant(d, "B_H",SWIG_From_int(static_cast< int >(B_H)));
  SWIG_Python_SetConstant(d, "IL",SWIG_From_int(static_cast< int >(IL)));
  SWIG_Python_SetConstant(d, "IL_H",SWIG_From_int(static_cast< int >(IL_H)));
  SWIG_Python_SetConstant(d, "MMH",SWIG_From_int(static_cast< int >(MMH)));
  SWIG_Python_SetConstant(d, "MMH_H",SWIG_From_int(static_cast< int >(MMH_H)));
  SWIG_Python_SetConstant(d, "MMI",SWIG_From_int(static_cast< int >(MMI)));
  SWIG_Python_SetConstant(d, "MMI_H",SWIG_From_int(static_cast< int >(MMI_H)));
  SWIG_Python_SetConstant(d, "MMI1N",SWIG_From_int(static_cast< int >(MMI1N)));
  SWIG_Python_SetConstant(d, "MMI1N_H",SWIG_From_int(static_cast< int >(MMI1N_H)));
  SWIG_Python_SetConstant(d, "MMI23",SWIG_From_int(static_cast< int >(MMI23)));
  SWIG_Python_SetConstant(d, "MMI23_H",SWIG_From_int(static_cast< int >(MMI23_H)));
  SWIG_Python_SetConstant(d, "MMM",SWIG_From_int(static_cast< int >(MMM)));
  SWIG_Python_SetConstant(d, "MMM_H",SWIG_From_int(static_cast< int >(MMM_H)));
  SWIG_Python_SetConstant(d, "MME",SWIG_From_int(static_cast< int >(MME)));
  SWIG_Python_SetConstant(d, "MME_H",SWIG_From_int(static_cast< int >(MME_H)));
  SWIG_Python_SetConstant(d, "D5",SWIG_From_int(static_cast< int >(D5)));
  SWIG_Python_SetConstant(d, "D5_H",SWIG_From_int(static_cast< int >(D5_H)));
  SWIG_Python_SetConstant(d, "D3",SWIG_From_int(static_cast< int >(D3)));
  SWIG_Python_SetConstant(d, "D3_H",SWIG_From_int(static_cast< int >(D3_H)));
  SWIG_Python_SetConstant(d, "INT11",SWIG_From_int(static_cast< int >(INT11)));
  SWIG_Python_SetConstant(d, "INT11_H",SWIG_From_int(static_cast< int >(INT11_H)));
  SWIG_Python_SetConstant(d, "INT21",SWIG_From_int(static_cast< int >(INT21)));
  SWIG_Python_SetConstant(d, "INT21_H",SWIG_From_int(static_cast< int >(INT21_H)));
  SWIG_Python_SetConstant(d, "INT22",SWIG_From_int(static_cast< int >(INT22)));
  SWIG_Python_SetConstant(d, "INT22_H",SWIG_From_int(static_cast< int >(INT22_H)));
  SWIG_Python_SetConstant(d, "ML",SWIG_From_int(static_cast< int >(ML)));
  SWIG_Python_SetConstant(d, "TL",SWIG_From_int(static_cast< int >(TL)));
  SWIG_Python_SetConstant(d, "TRI",SWIG_From_int(static_cast< int >(TRI)));
  SWIG_Python_SetConstant(d, "HEX",SWIG_From_int(static_cast< int >(HEX)));
  SWIG_Python_SetConstant(d, "NIN",SWIG_From_int(static_cast< int >(NIN)));
  SWIG_Python_SetConstant(d, "MISC",SWIG_From_int(static_cast< int >(MISC)));
  SWIG_Python_SetConstant(d, "GASCONST",SWIG_From_double(static_cast< double >(1.98717)));
  SWIG_Python_SetConstant(d, "K0",SWIG_From_double(static_cast< double >(273.15)));
  SWIG_Python_SetConstant(d, "INF",SWIG_From_int(static_cast< int >(10000000)));
  SWIG_Python_SetConstant(d, "EMAX",SWIG_From_int(static_cast< int >((10000000/10))));
  SWIG_Python_SetConstant(d, "FORBIDDEN",SWIG_From_int(static_cast< int >(9999)));
  SWIG_Python_SetConstant(d, "BONUS",SWIG_From_int(static_cast< int >(10000)));
  SWIG_Python_SetConstant(d, "NBPAIRS",SWIG_From_int(static_cast< int >(7)));
  SWIG_Python_SetConstant(d, "TURN",SWIG_From_int(static_cast< int >(3)));
  SWIG_Python_SetConstant(d, "MAXLOOP",SWIG_From_int(static_cast< int >(30)));
  SWIG_Python_SetConstant(d, "UNIT",SWIG_From_int(static_cast< int >(100)));
  SWIG_Python_SetConstant(d, "MINPSCORE",SWIG_From_int(static_cast< int >(-2*100)));
  SWIG_Python_SetConstant(d, "PI",SWIG_From_double(static_cast< double >(3.141592653589793)));
  globals = SWIG_globals();
  if (!globals) {
    PyErr_SetString(PyExc_TypeError, "Failure to create SWIG globals.");
    return -1;
  }
  PyDict_SetItemString(md, "cvar", globals);
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_TEMPERATURE",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_TEMPERATURE)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_PF_SCALE",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_PF_SCALE)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_BETA_SCALE",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_BETA_SCALE)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_DANGLES",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_DANGLES)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_SPECIAL_HP",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_SPECIAL_HP)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_NO_LP",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_NO_LP)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_NO_GU",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_NO_GU)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_NO_GU_CLOSURE",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_NO_GU_CLOSURE)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_CIRC",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_CIRC)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_CIRC_PENALTY",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_CIRC_PENALTY)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_GQUAD",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_GQUAD)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_UNIQ_ML",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_UNIQ_ML)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_ENERGY_SET",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_ENERGY_SET)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_BACKTRACK",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_BACKTRACK)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_BACKTRACK_TYPE",SWIG_From_char(static_cast< char >(VRNA_MODEL_DEFAULT_BACKTRACK_TYPE)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_COMPUTE_BPP",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_COMPUTE_BPP)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_MAX_BP_SPAN",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_MAX_BP_SPAN)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_WINDOW_SIZE",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_WINDOW_SIZE)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_LOG_ML",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_LOG_ML)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_ALI_OLD_EN",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_ALI_OLD_EN)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_ALI_RIBO",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_ALI_RIBO)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_ALI_CV_FACT",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_ALI_CV_FACT)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_ALI_NC_FACT",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_ALI_NC_FACT)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_PF_SMOOTH",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_PF_SMOOTH)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_SALT",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_SALT)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_SALT_MLLOWER",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_SALT_MLLOWER)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_SALT_MLUPPER",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_SALT_MLUPPER)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_SALT_DPXINIT",SWIG_From_int(static_cast< int >(VRNA_MODEL_DEFAULT_SALT_DPXINIT)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_SALT_DPXINIT_FACT",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_SALT_DPXINIT_FACT)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_HELICAL_RISE",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_HELICAL_RISE)));
  SWIG_Python_SetConstant(d, "MODEL_DEFAULT_BACKBONE_LENGTH",SWIG_From_double(static_cast< double >(VRNA_MODEL_DEFAULT_BACKBONE_LENGTH)));
  SWIG_Python_SetConstant(d, "MODEL_SALT_DPXINIT_FACT_RNA",SWIG_From_double(static_cast< double >(VRNA_MODEL_SALT_DPXINIT_FACT_RNA)));
  SWIG_Python_SetConstant(d, "MODEL_SALT_DPXINIT_FACT_DNA",SWIG_From_double(static_cast< double >(VRNA_MODEL_SALT_DPXINIT_FACT_DNA)));
  SWIG_Python_SetConstant(d, "MODEL_HELICAL_RISE_RNA",SWIG_From_double(static_cast< double >(VRNA_MODEL_HELICAL_RISE_RNA)));
  SWIG_Python_SetConstant(d, "MODEL_HELICAL_RISE_DNA",SWIG_From_double(static_cast< double >(VRNA_MODEL_HELICAL_RISE_DNA)));
  SWIG_Python_SetConstant(d, "MODEL_BACKBONE_LENGTH_RNA",SWIG_From_double(static_cast< double >(VRNA_MODEL_BACKBONE_LENGTH_RNA)));
  SWIG_Python_SetConstant(d, "MODEL_BACKBONE_LENGTH_DNA",SWIG_From_double(static_cast< double >(VRNA_MODEL_BACKBONE_LENGTH_DNA)));
  SWIG_Python_SetConstant(d, "NBASES",SWIG_From_int(static_cast< int >(8)));
  SWIG_Python_SetConstant(d, "MAXALPHA",SWIG_From_int(static_cast< int >(20)));
  SWIG_Python_SetConstant(d, "TRIM_LEADING",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_TRIM_LEADING)));
  SWIG_Python_SetConstant(d, "TRIM_TRAILING",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_TRIM_TRAILING)));
  SWIG_Python_SetConstant(d, "TRIM_IN_BETWEEN",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_TRIM_IN_BETWEEN)));
  SWIG_Python_SetConstant(d, "TRIM_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_TRIM_DEFAULT)));
  SWIG_Python_SetConstant(d, "TRIM_ALL",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_TRIM_ALL)));
  SWIG_Python_SetConstant(d, "FILENAME_MAX_LENGTH",SWIG_From_int(static_cast< int >(80)));
  SWIG_Python_SetConstant(d, "FILENAME_ID_LENGTH",SWIG_From_int(static_cast< int >(42)));
  SWIG_Python_SetConstant(d, "PLIST_TYPE_BASEPAIR",SWIG_From_int(static_cast< int >(VRNA_PLIST_TYPE_BASEPAIR)));
  SWIG_Python_SetConstant(d, "PLIST_TYPE_GQUAD",SWIG_From_int(static_cast< int >(VRNA_PLIST_TYPE_GQUAD)));
  SWIG_Python_SetConstant(d, "PLIST_TYPE_H_MOTIF",SWIG_From_int(static_cast< int >(VRNA_PLIST_TYPE_H_MOTIF)));
  SWIG_Python_SetConstant(d, "PLIST_TYPE_I_MOTIF",SWIG_From_int(static_cast< int >(VRNA_PLIST_TYPE_I_MOTIF)));
  SWIG_Python_SetConstant(d, "PLIST_TYPE_UD_MOTIF",SWIG_From_int(static_cast< int >(VRNA_PLIST_TYPE_UD_MOTIF)));
  SWIG_Python_SetConstant(d, "PLIST_TYPE_STACK",SWIG_From_int(static_cast< int >(VRNA_PLIST_TYPE_STACK)));
  SWIG_Python_SetConstant(d, "PLIST_TYPE_UNPAIRED",SWIG_From_int(static_cast< int >(VRNA_PLIST_TYPE_UNPAIRED)));
  SWIG_Python_SetConstant(d, "STRUCTURE_TREE_HIT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_STRUCTURE_TREE_HIT)));
  SWIG_Python_SetConstant(d, "STRUCTURE_TREE_SHAPIRO_SHORT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_STRUCTURE_TREE_SHAPIRO_SHORT)));
  SWIG_Python_SetConstant(d, "STRUCTURE_TREE_SHAPIRO",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_STRUCTURE_TREE_SHAPIRO)));
  SWIG_Python_SetConstant(d, "STRUCTURE_TREE_SHAPIRO_EXT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_STRUCTURE_TREE_SHAPIRO_EXT)));
  SWIG_Python_SetConstant(d, "STRUCTURE_TREE_SHAPIRO_WEIGHT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_STRUCTURE_TREE_SHAPIRO_WEIGHT)));
  SWIG_Python_SetConstant(d, "STRUCTURE_TREE_EXPANDED",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_STRUCTURE_TREE_EXPANDED)));
  SWIG_Python_SetConstant(d, "BRACKETS_RND",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_BRACKETS_RND)));
  SWIG_Python_SetConstant(d, "BRACKETS_ANG",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_BRACKETS_ANG)));
  SWIG_Python_SetConstant(d, "BRACKETS_SQR",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_BRACKETS_SQR)));
  SWIG_Python_SetConstant(d, "BRACKETS_CLY",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_BRACKETS_CLY)));
  SWIG_Python_SetConstant(d, "BRACKETS_ALPHA",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_BRACKETS_ALPHA)));
  SWIG_Python_SetConstant(d, "BRACKETS_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_BRACKETS_DEFAULT)));
  SWIG_Python_SetConstant(d, "BRACKETS_ANY",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_BRACKETS_ANY)));
  SWIG_Python_SetConstant(d, "ALN_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ALN_DEFAULT)));
  SWIG_Python_SetConstant(d, "ALN_RNA",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ALN_RNA)));
  SWIG_Python_SetConstant(d, "ALN_DNA",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ALN_DNA)));
  SWIG_Python_SetConstant(d, "ALN_UPPERCASE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ALN_UPPERCASE)));
  SWIG_Python_SetConstant(d, "ALN_LOWERCASE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ALN_LOWERCASE)));
  SWIG_Python_SetConstant(d, "MEASURE_SHANNON_ENTROPY",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_MEASURE_SHANNON_ENTROPY)));
  SWIG_Python_SetConstant(d, "GRADIENT",SWIG_From_int(static_cast< int >(GRADIENT)));
  SWIG_Python_SetConstant(d, "FIRST",SWIG_From_int(static_cast< int >(FIRST)));
  SWIG_Python_SetConstant(d, "ADAPTIVE",SWIG_From_int(static_cast< int >(ADAPTIVE)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_UNKNOWN",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_UNKNOWN)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_DEBUG",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_DEBUG)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_INFO",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_INFO)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_WARNING",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_WARNING)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_ERROR",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_ERROR)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_CRITICAL",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_CRITICAL)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_SILENT",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_SILENT)));
  SWIG_Python_SetConstant(d, "LOG_LEVEL_DEFAULT",SWIG_From_int(static_cast< int >(VRNA_LOG_LEVEL_DEFAULT)));
  SWIG_Python_SetConstant(d, "LOG_OPTION_QUIET",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_LOG_OPTION_QUIET)));
  SWIG_Python_SetConstant(d, "LOG_OPTION_TRACE_CALL",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_LOG_OPTION_TRACE_CALL)));
  SWIG_Python_SetConstant(d, "LOG_OPTION_TRACE_TIME",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_LOG_OPTION_TRACE_TIME)));
  SWIG_Python_SetConstant(d, "LOG_OPTION_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_LOG_OPTION_DEFAULT)));
  SWIG_Python_SetConstant(d, "PLOT_TYPE_SIMPLE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PLOT_TYPE_SIMPLE)));
  SWIG_Python_SetConstant(d, "PLOT_TYPE_NAVIEW",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PLOT_TYPE_NAVIEW)));
  SWIG_Python_SetConstant(d, "PLOT_TYPE_CIRCULAR",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PLOT_TYPE_CIRCULAR)));
  SWIG_Python_SetConstant(d, "PLOT_TYPE_TURTLE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PLOT_TYPE_TURTLE)));
  SWIG_Python_SetConstant(d, "PLOT_TYPE_PUZZLER",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PLOT_TYPE_PUZZLER)));
  SWIG_Python_SetConstant(d, "PLOT_TYPE_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PLOT_TYPE_DEFAULT)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_EPS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_EPS)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_SVG",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_SVG)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_GML",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_GML)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_SSV",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_SSV)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_XRNA",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_XRNA)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_PLOT_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_PLOT_DEFAULT)));
  SWIG_Python_SetConstant(d, "DECOMP_PAIR_HP",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_PAIR_HP)));
  SWIG_Python_SetConstant(d, "DECOMP_PAIR_IL",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_PAIR_IL)));
  SWIG_Python_SetConstant(d, "DECOMP_PAIR_ML",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_PAIR_ML)));
  SWIG_Python_SetConstant(d, "DECOMP_ML_ML_ML",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_ML_ML_ML)));
  SWIG_Python_SetConstant(d, "DECOMP_ML_STEM",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_ML_STEM)));
  SWIG_Python_SetConstant(d, "DECOMP_ML_ML",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_ML_ML)));
  SWIG_Python_SetConstant(d, "DECOMP_ML_UP",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_ML_UP)));
  SWIG_Python_SetConstant(d, "DECOMP_ML_ML_STEM",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_ML_ML_STEM)));
  SWIG_Python_SetConstant(d, "DECOMP_ML_COAXIAL",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_ML_COAXIAL)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_EXT",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_EXT)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_UP",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_UP)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_STEM",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_STEM)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_EXT_EXT",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_EXT_EXT)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_STEM_EXT",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_STEM_EXT)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_STEM_OUTSIDE",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_STEM_OUTSIDE)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_EXT_STEM",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_EXT_STEM)));
  SWIG_Python_SetConstant(d, "DECOMP_EXT_EXT_STEM1",SWIG_From_int(static_cast< int >((int) VRNA_DECOMP_EXT_EXT_STEM1)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_ENFORCE_BP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_ENFORCE_BP)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_PIPE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_PIPE)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_DOT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_DOT)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_X",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_X)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_ANG_BRACK",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_ANG_BRACK)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_RND_BRACK",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_RND_BRACK)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_INTRAMOL",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_INTRAMOL)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_INTERMOL",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_INTERMOL)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_GQUAD",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_GQUAD)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_DB_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_DB_DEFAULT)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_EXT_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_EXT_LOOP)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_HP_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_HP_LOOP)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_INT_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_INT_LOOP)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_INT_LOOP_ENC",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_INT_LOOP_ENC)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_MB_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_MB_LOOP)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_MB_LOOP_ENC",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_MB_LOOP_ENC)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_ENFORCE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_ENFORCE)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_NO_REMOVE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_NO_REMOVE)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_ALL_LOOPS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_ALL_LOOPS)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_NONE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_NONE)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_CLOSING_LOOPS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_CLOSING_LOOPS)));
  SWIG_Python_SetConstant(d, "CONSTRAINT_CONTEXT_ENCLOSED_LOOPS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CONSTRAINT_CONTEXT_ENCLOSED_LOOPS)));
  SWIG_Python_SetConstant(d, "SC_MOD_CHECK_FALLBACK",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_SC_MOD_CHECK_FALLBACK)));
  SWIG_Python_SetConstant(d, "SC_MOD_CHECK_UNMOD",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_SC_MOD_CHECK_UNMOD)));
  SWIG_Python_SetConstant(d, "SC_MOD_SILENT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_SC_MOD_SILENT)));
  SWIG_Python_SetConstant(d, "SC_MOD_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_SC_MOD_DEFAULT)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_MULTI_PARAMS_0",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_METHOD_MULTI_PARAMS_0)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_MULTI_PARAMS_1",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_METHOD_MULTI_PARAMS_1)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_MULTI_PARAMS_2",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_METHOD_MULTI_PARAMS_2)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_MULTI_PARAMS_3",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_METHOD_MULTI_PARAMS_3)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_MULTI_PARAMS_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_METHOD_MULTI_PARAMS_DEFAULT)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_CHECK_SEQUENCE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_CHECK_SEQUENCE)));
  SWIG_Python_SetConstant(d, "REACTIVITY_MISSING",SWIG_From_double(static_cast< double >(VRNA_REACTIVITY_MISSING)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_WEIGHT_POSITION_WISE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_WEIGHT_POSITION_WISE)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_SINGLE_STRATEGY",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_SINGLE_STRATEGY)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_SINGLE_WEIGHT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_SINGLE_WEIGHT)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_DEFAULT)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_LINEAR_TARGET_STACK",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_LINEAR_TARGET_STACK)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_LINEAR_TARGET_UP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_LINEAR_TARGET_UP)));
  SWIG_Python_SetConstant(d, "PROBING_DATA_LINEAR_TARGET_BP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_DATA_LINEAR_TARGET_BP)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_DEIGAN2009_DEFAULT_m",SWIG_From_double(static_cast< double >(VRNA_PROBING_METHOD_DEIGAN2009_DEFAULT_m)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_DEIGAN2009_DEFAULT_b",SWIG_From_double(static_cast< double >(VRNA_PROBING_METHOD_DEIGAN2009_DEFAULT_b)));
  SWIG_Python_SetConstant(d, "PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_STRATEGY_EDDY_OPTIONS_DEFAULT)));
  SWIG_Python_SetConstant(d, "PROBING_STRATEGY_EDDY_NO_TEMPERATURE_RESCALING",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBING_STRATEGY_EDDY_NO_TEMPERATURE_RESCALING)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_beta",SWIG_From_double(static_cast< double >(VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_beta)));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion",SWIG_FromCharPtr(VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_conversion));
  SWIG_Python_SetConstant(d, "PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability",SWIG_From_double(static_cast< double >(VRNA_PROBING_METHOD_ZARRINGHALAM2012_DEFAULT_probability)));
  SWIG_Python_SetConstant(d, "ZSCORE_OPTIONS_NONE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ZSCORE_OPTIONS_NONE)));
  SWIG_Python_SetConstant(d, "ZSCORE_FILTER_ON",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ZSCORE_FILTER_ON)));
  SWIG_Python_SetConstant(d, "ZSCORE_PRE_FILTER",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ZSCORE_PRE_FILTER)));
  SWIG_Python_SetConstant(d, "ZSCORE_REPORT_SUBSUMED",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ZSCORE_REPORT_SUBSUMED)));
  SWIG_Python_SetConstant(d, "ZSCORE_MODEL_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ZSCORE_MODEL_DEFAULT)));
  SWIG_Python_SetConstant(d, "ZSCORE_SETTINGS_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ZSCORE_SETTINGS_DEFAULT)));
  SWIG_Python_SetConstant(d, "PBACKTRACK_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PBACKTRACK_DEFAULT)));
  SWIG_Python_SetConstant(d, "PBACKTRACK_NON_REDUNDANT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PBACKTRACK_NON_REDUNDANT)));
  SWIG_Python_SetConstant(d, "EXT_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_EXT_LOOP)));
  SWIG_Python_SetConstant(d, "HP_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_HP_LOOP)));
  SWIG_Python_SetConstant(d, "INT_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_INT_LOOP)));
  SWIG_Python_SetConstant(d, "MB_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_MB_LOOP)));
  SWIG_Python_SetConstant(d, "ANY_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_ANY_LOOP)));
  SWIG_Python_SetConstant(d, "PROBS_WINDOW_BPP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBS_WINDOW_BPP)));
  SWIG_Python_SetConstant(d, "PROBS_WINDOW_UP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBS_WINDOW_UP)));
  SWIG_Python_SetConstant(d, "PROBS_WINDOW_STACKP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBS_WINDOW_STACKP)));
  SWIG_Python_SetConstant(d, "PROBS_WINDOW_UP_SPLIT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBS_WINDOW_UP_SPLIT)));
  SWIG_Python_SetConstant(d, "PROBS_WINDOW_PF",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PROBS_WINDOW_PF)));
  SWIG_Python_SetConstant(d, "MAXDOS",SWIG_From_int(static_cast< int >(1000)));
  
  /* work around segfault when script tries to free symbolset */
  
  symbolset = (char *) vrna_alloc(sizeof(char) * 5);
  strncpy(symbolset, "AUGC", sizeof(char) * 5);
  
  
  SWIG_Python_SetConstant(d, "INPUT_ERROR",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(1U)));
  SWIG_Python_SetConstant(d, "INPUT_QUIT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(2U)));
  SWIG_Python_SetConstant(d, "INPUT_MISC",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4U)));
  SWIG_Python_SetConstant(d, "INPUT_FASTA_HEADER",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(8U)));
  SWIG_Python_SetConstant(d, "INPUT_SEQUENCE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(16U)));
  SWIG_Python_SetConstant(d, "INPUT_CONSTRAINT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(32U)));
  SWIG_Python_SetConstant(d, "INPUT_NO_TRUNCATION",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(256U)));
  SWIG_Python_SetConstant(d, "INPUT_NO_SPAN",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(1024U)));
  SWIG_Python_SetConstant(d, "INPUT_NO_REST",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(512U)));
  SWIG_Python_SetConstant(d, "INPUT_NOSKIP_BLANK_LINES",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(2048U)));
  SWIG_Python_SetConstant(d, "INPUT_BLANK_LINE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(4096U)));
  SWIG_Python_SetConstant(d, "INPUT_NOSKIP_COMMENTS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(128U)));
  SWIG_Python_SetConstant(d, "INPUT_COMMENT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(8192U)));
  SWIG_Python_SetConstant(d, "OPTION_MULTILINE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_OPTION_MULTILINE)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_CLUSTAL",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_CLUSTAL)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_DEFAULT)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_FASTA",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_FASTA)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_MAF",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_MAF)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_NOCHECK",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_NOCHECK)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_STOCKHOLM",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_STOCKHOLM)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_MIS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_MIS)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_UNKNOWN",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_UNKNOWN)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_QUIET",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_QUIET)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_SILENT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_SILENT)));
  SWIG_Python_SetConstant(d, "FILE_FORMAT_MSA_APPEND",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_FILE_FORMAT_MSA_APPEND)));
  SWIG_Python_SetConstant(d, "SEQUENCE_RNA",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_SEQUENCE_RNA)));
  SWIG_Python_SetConstant(d, "SEQUENCE_DNA",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_SEQUENCE_DNA)));
  SWIG_Python_SetConstant(d, "UNSTRUCTURED_DOMAIN_EXT_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_UNSTRUCTURED_DOMAIN_EXT_LOOP)));
  SWIG_Python_SetConstant(d, "UNSTRUCTURED_DOMAIN_HP_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_UNSTRUCTURED_DOMAIN_HP_LOOP)));
  SWIG_Python_SetConstant(d, "UNSTRUCTURED_DOMAIN_INT_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_UNSTRUCTURED_DOMAIN_INT_LOOP)));
  SWIG_Python_SetConstant(d, "UNSTRUCTURED_DOMAIN_MB_LOOP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_UNSTRUCTURED_DOMAIN_MB_LOOP)));
  SWIG_Python_SetConstant(d, "UNSTRUCTURED_DOMAIN_ALL_LOOPS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_UNSTRUCTURED_DOMAIN_ALL_LOOPS)));
  SWIG_Python_SetConstant(d, "UNSTRUCTURED_DOMAIN_MOTIF",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_UNSTRUCTURED_DOMAIN_MOTIF)));
  SWIG_Python_SetConstant(d, "CMD_PARSE_DEFAULTS",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CMD_PARSE_DEFAULTS)));
  SWIG_Python_SetConstant(d, "CMD_PARSE_HC",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CMD_PARSE_HC)));
  SWIG_Python_SetConstant(d, "CMD_PARSE_SC",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CMD_PARSE_SC)));
  SWIG_Python_SetConstant(d, "CMD_PARSE_SD",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CMD_PARSE_SD)));
  SWIG_Python_SetConstant(d, "CMD_PARSE_UD",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_CMD_PARSE_UD)));
  SWIG_Python_SetConstant(d, "MOVESET_INSERTION",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_MOVESET_INSERTION)));
  SWIG_Python_SetConstant(d, "MOVESET_DELETION",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_MOVESET_DELETION)));
  SWIG_Python_SetConstant(d, "MOVESET_SHIFT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_MOVESET_SHIFT)));
  SWIG_Python_SetConstant(d, "MOVESET_NO_LP",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_MOVESET_NO_LP)));
  SWIG_Python_SetConstant(d, "MOVESET_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_MOVESET_DEFAULT)));
  SWIG_Python_SetConstant(d, "NEIGHBOR_CHANGE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_NEIGHBOR_CHANGE)));
  SWIG_Python_SetConstant(d, "NEIGHBOR_INVALID",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_NEIGHBOR_INVALID)));
  SWIG_Python_SetConstant(d, "NEIGHBOR_NEW",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_NEIGHBOR_NEW)));
  SWIG_Python_SetConstant(d, "PATH_STEEPEST_DESCENT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PATH_STEEPEST_DESCENT)));
  SWIG_Python_SetConstant(d, "PATH_RANDOM",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PATH_RANDOM)));
  SWIG_Python_SetConstant(d, "PATH_NO_TRANSITION_OUTPUT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PATH_NO_TRANSITION_OUTPUT)));
  SWIG_Python_SetConstant(d, "PATH_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PATH_DEFAULT)));
  SWIG_Python_SetConstant(d, "PATH_TYPE_DOT_BRACKET",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PATH_TYPE_DOT_BRACKET)));
  SWIG_Python_SetConstant(d, "PATH_TYPE_MOVES",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_PATH_TYPE_MOVES)));
  SWIG_Python_SetConstant(d, "FC_TYPE_SINGLE",SWIG_From_int(static_cast< int >(FC_TYPE_SINGLE)));
  SWIG_Python_SetConstant(d, "FC_TYPE_COMPARATIVE",SWIG_From_int(static_cast< int >(FC_TYPE_COMPARATIVE)));
  SWIG_Python_SetConstant(d, "STATUS_MFE_PRE",SWIG_From_unsigned_SS_char(static_cast< unsigned char >(VRNA_STATUS_MFE_PRE)));
  SWIG_Python_SetConstant(d, "STATUS_MFE_POST",SWIG_From_unsigned_SS_char(static_cast< unsigned char >(VRNA_STATUS_MFE_POST)));
  SWIG_Python_SetConstant(d, "STATUS_PF_PRE",SWIG_From_unsigned_SS_char(static_cast< unsigned char >(VRNA_STATUS_PF_PRE)));
  SWIG_Python_SetConstant(d, "STATUS_PF_POST",SWIG_From_unsigned_SS_char(static_cast< unsigned char >(VRNA_STATUS_PF_POST)));
  SWIG_Python_SetConstant(d, "OPTION_DEFAULT",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_OPTION_DEFAULT)));
  SWIG_Python_SetConstant(d, "OPTION_MFE",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_OPTION_MFE)));
  SWIG_Python_SetConstant(d, "OPTION_PF",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_OPTION_PF)));
  SWIG_Python_SetConstant(d, "OPTION_HYBRID",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_OPTION_HYBRID)));
  SWIG_Python_SetConstant(d, "OPTION_EVAL_ONLY",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_OPTION_EVAL_ONLY)));
  SWIG_Python_SetConstant(d, "OPTION_WINDOW",SWIG_From_unsigned_SS_int(static_cast< unsigned int >(VRNA_OPTION_WINDOW)));
  SWIG_addvarlink(globals, "lxc37", Swig_var_lxc37_get, Swig_var_lxc37_set);
  SWIG_addvarlink(globals, "stack37", Swig_var_stack37_get, Swig_var_stack37_set);
  SWIG_addvarlink(globals, "stackdH", Swig_var_stackdH_get, Swig_var_stackdH_set);
  SWIG_addvarlink(globals, "hairpin37", Swig_var_hairpin37_get, Swig_var_hairpin37_set);
  SWIG_addvarlink(globals, "hairpindH", Swig_var_hairpindH_get, Swig_var_hairpindH_set);
  SWIG_addvarlink(globals, "bulge37", Swig_var_bulge37_get, Swig_var_bulge37_set);
  SWIG_addvarlink(globals, "bulgedH", Swig_var_bulgedH_get, Swig_var_bulgedH_set);
  SWIG_addvarlink(globals, "internal_loop37", Swig_var_internal_loop37_get, Swig_var_internal_loop37_set);
  SWIG_addvarlink(globals, "internal_loopdH", Swig_var_internal_loopdH_get, Swig_var_internal_loopdH_set);
  SWIG_addvarlink(globals, "mismatchI37", Swig_var_mismatchI37_get, Swig_var_mismatchI37_set);
  SWIG_addvarlink(globals, "mismatchIdH", Swig_var_mismatchIdH_get, Swig_var_mismatchIdH_set);
  SWIG_addvarlink(globals, "mismatch1nI37", Swig_var_mismatch1nI37_get, Swig_var_mismatch1nI37_set);
  SWIG_addvarlink(globals, "mismatch23I37", Swig_var_mismatch23I37_get, Swig_var_mismatch23I37_set);
  SWIG_addvarlink(globals, "mismatch1nIdH", Swig_var_mismatch1nIdH_get, Swig_var_mismatch1nIdH_set);
  SWIG_addvarlink(globals, "mismatch23IdH", Swig_var_mismatch23IdH_get, Swig_var_mismatch23IdH_set);
  SWIG_addvarlink(globals, "mismatchH37", Swig_var_mismatchH37_get, Swig_var_mismatchH37_set);
  SWIG_addvarlink(globals, "mismatchM37", Swig_var_mismatchM37_get, Swig_var_mismatchM37_set);
  SWIG_addvarlink(globals, "mismatchHdH", Swig_var_mismatchHdH_get, Swig_var_mismatchHdH_set);
  SWIG_addvarlink(globals, "mismatchMdH", Swig_var_mismatchMdH_get, Swig_var_mismatchMdH_set);
  SWIG_addvarlink(globals, "mismatchExt37", Swig_var_mismatchExt37_get, Swig_var_mismatchExt37_set);
  SWIG_addvarlink(globals, "mismatchExtdH", Swig_var_mismatchExtdH_get, Swig_var_mismatchExtdH_set);
  SWIG_addvarlink(globals, "dangle5_37", Swig_var_dangle5_37_get, Swig_var_dangle5_37_set);
  SWIG_addvarlink(globals, "dangle3_37", Swig_var_dangle3_37_get, Swig_var_dangle3_37_set);
  SWIG_addvarlink(globals, "dangle3_dH", Swig_var_dangle3_dH_get, Swig_var_dangle3_dH_set);
  SWIG_addvarlink(globals, "dangle5_dH", Swig_var_dangle5_dH_get, Swig_var_dangle5_dH_set);
  SWIG_addvarlink(globals, "int11_37", Swig_var_int11_37_get, Swig_var_int11_37_set);
  SWIG_addvarlink(globals, "int11_dH", Swig_var_int11_dH_get, Swig_var_int11_dH_set);
  SWIG_addvarlink(globals, "int21_37", Swig_var_int21_37_get, Swig_var_int21_37_set);
  SWIG_addvarlink(globals, "int21_dH", Swig_var_int21_dH_get, Swig_var_int21_dH_set);
  SWIG_addvarlink(globals, "int22_37", Swig_var_int22_37_get, Swig_var_int22_37_set);
  SWIG_addvarlink(globals, "int22_dH", Swig_var_int22_dH_get, Swig_var_int22_dH_set);
  SWIG_addvarlink(globals, "ML_BASE37", Swig_var_ML_BASE37_get, Swig_var_ML_BASE37_set);
  SWIG_addvarlink(globals, "ML_BASEdH", Swig_var_ML_BASEdH_get, Swig_var_ML_BASEdH_set);
  SWIG_addvarlink(globals, "ML_closing37", Swig_var_ML_closing37_get, Swig_var_ML_closing37_set);
  SWIG_addvarlink(globals, "ML_closingdH", Swig_var_ML_closingdH_get, Swig_var_ML_closingdH_set);
  SWIG_addvarlink(globals, "ML_intern37", Swig_var_ML_intern37_get, Swig_var_ML_intern37_set);
  SWIG_addvarlink(globals, "ML_interndH", Swig_var_ML_interndH_get, Swig_var_ML_interndH_set);
  SWIG_addvarlink(globals, "TripleC37", Swig_var_TripleC37_get, Swig_var_TripleC37_set);
  SWIG_addvarlink(globals, "TripleCdH", Swig_var_TripleCdH_get, Swig_var_TripleCdH_set);
  SWIG_addvarlink(globals, "MultipleCA37", Swig_var_MultipleCA37_get, Swig_var_MultipleCA37_set);
  SWIG_addvarlink(globals, "MultipleCAdH", Swig_var_MultipleCAdH_get, Swig_var_MultipleCAdH_set);
  SWIG_addvarlink(globals, "MultipleCB37", Swig_var_MultipleCB37_get, Swig_var_MultipleCB37_set);
  SWIG_addvarlink(globals, "MultipleCBdH", Swig_var_MultipleCBdH_get, Swig_var_MultipleCBdH_set);
  SWIG_addvarlink(globals, "MAX_NINIO", Swig_var_MAX_NINIO_get, Swig_var_MAX_NINIO_set);
  SWIG_addvarlink(globals, "ninio37", Swig_var_ninio37_get, Swig_var_ninio37_set);
  SWIG_addvarlink(globals, "niniodH", Swig_var_niniodH_get, Swig_var_niniodH_set);
  SWIG_addvarlink(globals, "TerminalAU37", Swig_var_TerminalAU37_get, Swig_var_TerminalAU37_set);
  SWIG_addvarlink(globals, "TerminalAUdH", Swig_var_TerminalAUdH_get, Swig_var_TerminalAUdH_set);
  SWIG_addvarlink(globals, "DuplexInit37", Swig_var_DuplexInit37_get, Swig_var_DuplexInit37_set);
  SWIG_addvarlink(globals, "DuplexInitdH", Swig_var_DuplexInitdH_get, Swig_var_DuplexInitdH_set);
  SWIG_addvarlink(globals, "Tetraloops", Swig_var_Tetraloops_get, Swig_var_Tetraloops_set);
  SWIG_addvarlink(globals, "Tetraloop37", Swig_var_Tetraloop37_get, Swig_var_Tetraloop37_set);
  SWIG_addvarlink(globals, "TetraloopdH", Swig_var_TetraloopdH_get, Swig_var_TetraloopdH_set);
  SWIG_addvarlink(globals, "Triloops", Swig_var_Triloops_get, Swig_var_Triloops_set);
  SWIG_addvarlink(globals, "Triloop37", Swig_var_Triloop37_get, Swig_var_Triloop37_set);
  SWIG_addvarlink(globals, "TriloopdH", Swig_var_TriloopdH_get, Swig_var_TriloopdH_set);
  SWIG_addvarlink(globals, "Hexaloops", Swig_var_Hexaloops_get, Swig_var_Hexaloops_set);
  SWIG_addvarlink(globals, "Hexaloop37", Swig_var_Hexaloop37_get, Swig_var_Hexaloop37_set);
  SWIG_addvarlink(globals, "HexaloopdH", Swig_var_HexaloopdH_get, Swig_var_HexaloopdH_set);
  SWIG_addvarlink(globals, "GQuadAlpha37", Swig_var_GQuadAlpha37_get, Swig_var_GQuadAlpha37_set);
  SWIG_addvarlink(globals, "GQuadAlphadH", Swig_var_GQuadAlphadH_get, Swig_var_GQuadAlphadH_set);
  SWIG_addvarlink(globals, "GQuadBeta37", Swig_var_GQuadBeta37_get, Swig_var_GQuadBeta37_set);
  SWIG_addvarlink(globals, "GQuadBetadH", Swig_var_GQuadBetadH_get, Swig_var_GQuadBetadH_set);
  SWIG_addvarlink(globals, "GQuadLayerMismatch37", Swig_var_GQuadLayerMismatch37_get, Swig_var_GQuadLayerMismatch37_set);
  SWIG_addvarlink(globals, "GQuadLayerMismatchH", Swig_var_GQuadLayerMismatchH_get, Swig_var_GQuadLayerMismatchH_set);
  SWIG_addvarlink(globals, "GQuadLayerMismatchMax", Swig_var_GQuadLayerMismatchMax_get, Swig_var_GQuadLayerMismatchMax_set);
  SWIG_addvarlink(globals, "Tmeasure", Swig_var_Tmeasure_get, Swig_var_Tmeasure_set);
  SWIG_addvarlink(globals, "temperature", Swig_var_temperature_get, Swig_var_temperature_set);
  SWIG_addvarlink(globals, "dangles", Swig_var_dangles_get, Swig_var_dangles_set);
  SWIG_addvarlink(globals, "betaScale", Swig_var_betaScale_get, Swig_var_betaScale_set);
  SWIG_addvarlink(globals, "pf_smooth", Swig_var_pf_smooth_get, Swig_var_pf_smooth_set);
  SWIG_addvarlink(globals, "tetra_loop", Swig_var_tetra_loop_get, Swig_var_tetra_loop_set);
  SWIG_addvarlink(globals, "special_hp", Swig_var_special_hp_get, Swig_var_special_hp_set);
  SWIG_addvarlink(globals, "noLonelyPairs", Swig_var_noLonelyPairs_get, Swig_var_noLonelyPairs_set);
  SWIG_addvarlink(globals, "noLP", Swig_var_noLP_get, Swig_var_noLP_set);
  SWIG_addvarlink(globals, "noGU", Swig_var_noGU_get, Swig_var_noGU_set);
  SWIG_addvarlink(globals, "no_closingGU", Swig_var_no_closingGU_get, Swig_var_no_closingGU_set);
  SWIG_addvarlink(globals, "noGUclosure", Swig_var_noGUclosure_get, Swig_var_noGUclosure_set);
  SWIG_addvarlink(globals, "logML", Swig_var_logML_get, Swig_var_logML_set);
  SWIG_addvarlink(globals, "circ", Swig_var_circ_get, Swig_var_circ_set);
  SWIG_addvarlink(globals, "circ_penalty", Swig_var_circ_penalty_get, Swig_var_circ_penalty_set);
  SWIG_addvarlink(globals, "gquad", Swig_var_gquad_get, Swig_var_gquad_set);
  SWIG_addvarlink(globals, "uniq_ML", Swig_var_uniq_ML_get, Swig_var_uniq_ML_set);
  SWIG_addvarlink(globals, "energy_set", Swig_var_energy_set_get, Swig_var_energy_set_set);
  SWIG_addvarlink(globals, "backtrack", Swig_var_backtrack_get, Swig_var_backtrack_set);
  SWIG_addvarlink(globals, "backtrack_type", Swig_var_backtrack_type_get, Swig_var_backtrack_type_set);
  SWIG_addvarlink(globals, "do_backtrack", Swig_var_do_backtrack_get, Swig_var_do_backtrack_set);
  SWIG_addvarlink(globals, "compute_bpp", Swig_var_compute_bpp_get, Swig_var_compute_bpp_set);
  SWIG_addvarlink(globals, "max_bp_span", Swig_var_max_bp_span_get, Swig_var_max_bp_span_set);
  SWIG_addvarlink(globals, "min_loop_size", Swig_var_min_loop_size_get, Swig_var_min_loop_size_set);
  SWIG_addvarlink(globals, "window_size", Swig_var_window_size_get, Swig_var_window_size_set);
  SWIG_addvarlink(globals, "oldAliEn", Swig_var_oldAliEn_get, Swig_var_oldAliEn_set);
  SWIG_addvarlink(globals, "ribo", Swig_var_ribo_get, Swig_var_ribo_set);
  SWIG_addvarlink(globals, "cv_fact", Swig_var_cv_fact_get, Swig_var_cv_fact_set);
  SWIG_addvarlink(globals, "nc_fact", Swig_var_nc_fact_get, Swig_var_nc_fact_set);
  SWIG_addvarlink(globals, "sfact", Swig_var_sfact_get, Swig_var_sfact_set);
  SWIG_addvarlink(globals, "salt", Swig_var_salt_get, Swig_var_salt_set);
  SWIG_addvarlink(globals, "saltDPXInit", Swig_var_saltDPXInit_get, Swig_var_saltDPXInit_set);
  SWIG_addvarlink(globals, "saltDPXInitFact", Swig_var_saltDPXInitFact_get, Swig_var_saltDPXInitFact_set);
  SWIG_addvarlink(globals, "pf_scale", Swig_var_pf_scale_get, Swig_var_pf_scale_set);
  SWIG_addvarlink(globals, "nonstandards", Swig_var_nonstandards_get, Swig_var_nonstandards_set);
  SWIG_addvarlink(globals, "xsubi", Swig_var_xsubi_get, Swig_var_xsubi_set);
  SWIG_addvarlink(globals, "rna_plot_type", Swig_var_rna_plot_type_get, Swig_var_rna_plot_type_set);
  SWIG_addvarlink(globals, "cut_point", Swig_var_cut_point_get, Swig_var_cut_point_set);
  SWIG_addvarlink(globals, "eos_debug", Swig_var_eos_debug_get, Swig_var_eos_debug_set);
  SWIG_addvarlink(globals, "st_back", Swig_var_st_back_get, Swig_var_st_back_set);
  SWIG_addvarlink(globals, "mirnatog", Swig_var_mirnatog_get, Swig_var_mirnatog_set);
  SWIG_addvarlink(globals, "F_monomer", Swig_var_F_monomer_get, Swig_var_F_monomer_set);
  SWIG_addvarlink(globals, "subopt_sorted", Swig_var_subopt_sorted_get, Swig_var_subopt_sorted_set);
  SWIG_addvarlink(globals, "print_energy", Swig_var_print_energy_get, Swig_var_print_energy_set);
  SWIG_addvarlink(globals, "density_of_states", Swig_var_density_of_states_get, Swig_var_density_of_states_set);
  SWIG_addvarlink(globals, "symbolset", Swig_var_symbolset_get, Swig_var_symbolset_set);
  SWIG_addvarlink(globals, "final_cost", Swig_var_final_cost_get, Swig_var_final_cost_set);
  SWIG_addvarlink(globals, "give_up", Swig_var_give_up_get, Swig_var_give_up_set);
  SWIG_addvarlink(globals, "inv_verbose", Swig_var_inv_verbose_get, Swig_var_inv_verbose_set);
  SWIG_addvarlink(globals, "loop_size", Swig_var_loop_size_get, Swig_var_loop_size_set);
  SWIG_addvarlink(globals, "helix_size", Swig_var_helix_size_get, Swig_var_helix_size_set);
  SWIG_addvarlink(globals, "loop_degree", Swig_var_loop_degree_get, Swig_var_loop_degree_set);
  SWIG_addvarlink(globals, "loops", Swig_var_loops_get, Swig_var_loops_set);
  SWIG_addvarlink(globals, "unpaired", Swig_var_unpaired_get, Swig_var_unpaired_set);
  SWIG_addvarlink(globals, "pairs", Swig_var_pairs_get, Swig_var_pairs_set);
  SWIG_addvarlink(globals, "edit_backtrack", Swig_var_edit_backtrack_get, Swig_var_edit_backtrack_set);
  SWIG_addvarlink(globals, "aligned_line", Swig_var_aligned_line_get, Swig_var_aligned_line_set);
  SWIG_addvarlink(globals, "cost_matrix", Swig_var_cost_matrix_get, Swig_var_cost_matrix_set);
  SWIG_addvarlink(globals, "parameter_set_dna_mathews1999", Swig_var_parameter_set_dna_mathews1999_get, Swig_var_parameter_set_dna_mathews1999_set);
  SWIG_addvarlink(globals, "parameter_set_dna_mathews2004", Swig_var_parameter_set_dna_mathews2004_get, Swig_var_parameter_set_dna_mathews2004_set);
  SWIG_addvarlink(globals, "parameter_set_rna_andronescu2007", Swig_var_parameter_set_rna_andronescu2007_get, Swig_var_parameter_set_rna_andronescu2007_set);
  SWIG_addvarlink(globals, "parameter_set_rna_langdon2018", Swig_var_parameter_set_rna_langdon2018_get, Swig_var_parameter_set_rna_langdon2018_set);
  SWIG_addvarlink(globals, "parameter_set_rna_misc_special_hairpins", Swig_var_parameter_set_rna_misc_special_hairpins_get, Swig_var_parameter_set_rna_misc_special_hairpins_set);
  SWIG_addvarlink(globals, "parameter_set_rna_turner1999", Swig_var_parameter_set_rna_turner1999_get, Swig_var_parameter_set_rna_turner1999_set);
  SWIG_addvarlink(globals, "parameter_set_rna_turner2004", Swig_var_parameter_set_rna_turner2004_get, Swig_var_parameter_set_rna_turner2004_set);
  SWIG_addvarlink(globals, "parameter_set_rna_mod_7DA_parameters", Swig_var_parameter_set_rna_mod_7DA_parameters_get, Swig_var_parameter_set_rna_mod_7DA_parameters_set);
  SWIG_addvarlink(globals, "parameter_set_rna_mod_inosine_parameters", Swig_var_parameter_set_rna_mod_inosine_parameters_get, Swig_var_parameter_set_rna_mod_inosine_parameters_set);
  SWIG_addvarlink(globals, "parameter_set_rna_mod_m6A_parameters", Swig_var_parameter_set_rna_mod_m6A_parameters_get, Swig_var_parameter_set_rna_mod_m6A_parameters_set);
  SWIG_addvarlink(globals, "parameter_set_rna_mod_pseudouridine_parameters", Swig_var_parameter_set_rna_mod_pseudouridine_parameters_get, Swig_var_parameter_set_rna_mod_pseudouridine_parameters_set);
  SWIG_addvarlink(globals, "parameter_set_rna_mod_purine_parameters", Swig_var_parameter_set_rna_mod_purine_parameters_get, Swig_var_parameter_set_rna_mod_purine_parameters_set);
  SWIG_addvarlink(globals, "parameter_set_rna_mod_dihydrouridine_parameters", Swig_var_parameter_set_rna_mod_dihydrouridine_parameters_get, Swig_var_parameter_set_rna_mod_dihydrouridine_parameters_set);
  SWIG_addvarlink(globals, "probing_data_prior_probing_1M7_paired", Swig_var_probing_data_prior_probing_1M7_paired_get, Swig_var_probing_data_prior_probing_1M7_paired_set);
  SWIG_addvarlink(globals, "probing_data_prior_probing_1M7_unpaired", Swig_var_probing_data_prior_probing_1M7_unpaired_get, Swig_var_probing_data_prior_probing_1M7_unpaired_set);
  SWIG_addvarlink(globals, "probing_data_prior_probing_DMS_paired", Swig_var_probing_data_prior_probing_DMS_paired_get, Swig_var_probing_data_prior_probing_DMS_paired_set);
  SWIG_addvarlink(globals, "probing_data_prior_probing_DMS_unpaired", Swig_var_probing_data_prior_probing_DMS_unpaired_get, Swig_var_probing_data_prior_probing_DMS_unpaired_set);
  SWIG_addvarlink(globals, "base_pair", Swig_var_base_pair_get, Swig_var_base_pair_set);
  SWIG_addvarlink(globals, "pr", Swig_var_pr_get, Swig_var_pr_set);
  SWIG_addvarlink(globals, "iindx", Swig_var_iindx_get, Swig_var_iindx_set);
  SWIG_addvarlink(globals, "fold_constrained", Swig_var_fold_constrained_get, Swig_var_fold_constrained_set);
  SWIG_addvarlink(globals, "csv", Swig_var_csv_get, Swig_var_csv_set);
  SWIG_addvarlink(globals, "RibosumFile", Swig_var_RibosumFile_get, Swig_var_RibosumFile_set);
  SWIG_addvarlink(globals, "james_rule", Swig_var_james_rule_get, Swig_var_james_rule_set);
  return 0;
}

